function escapeRegExp(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

/**
 * Removes excluded text from a Node.
 *
 * @param {Node} target Node to filter.
 * @param {string} exclude CSS selector of nodes to exclude.
 * @returns {DOMString} Text from `target` with text removed.
 */
function filterText(target, exclude) {
    const clone = target.cloneNode(true);  // clone as to not modify the live DOM
    if (exclude) {
        // remove excluded nodes
        clone.querySelectorAll(exclude).forEach(node => node.remove());
    }
    return clone.innerText;
}

// Callback when a copy button is clicked. Will be passed the node that was clicked
// should then grab the text and replace pieces of text that shouldn't be used in output
function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") {
    var regexp;
    var match;

    // Do we check for line continuation characters and "HERE-documents"?
    var useLineCont = !!lineContinuationChar
    var useHereDoc = !!hereDocDelim

    // create regexp to capture prompt and remaining line
    if (isRegexp) {
        regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)')
    } else {
        regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)')
    }

    const outputLines = [];
    var promptFound = false;
    var gotLineCont = false;
    var gotHereDoc = false;
    const lineGotPrompt = [];
    for (const line of textContent.split('\n')) {
        match = line.match(regexp)
        if (match || gotLineCont || gotHereDoc) {
            promptFound = regexp.test(line)
            lineGotPrompt.push(promptFound)
            if (removePrompts && promptFound) {
                outputLines.push(match[2])
            } else {
                outputLines.push(line)
            }
            gotLineCont = line.endsWith(lineContinuationChar) & useLineCont
            if (line.includes(hereDocDelim) & useHereDoc)
                gotHereDoc = !gotHereDoc
        } else if (!onlyCopyPromptLines) {
            outputLines.push(line)
        } else if (copyEmptyLines && line.trim() === '') {
        }
    }

    // If no lines with the prompt were found then just use original lines
    if (lineGotPrompt.some(v => v === true)) {
        textContent = outputLines.join('\n');
    }

    // Remove a trailing newline to avoid auto-running when pasting
    if (textContent.endsWith("\n")) {
        textContent = textContent.slice(0, -1)
    }
    return textContent
}

kittycad.api.ai

Contains methods for accessing the ai API paths: AI uses machine learning to generate 3D meshes.

kittycad.api.api_calls

Contains methods for accessing the api_calls API paths: API calls that have been performed by users can be queried by the API.

kittycad.api.api_tokens

Contains methods for accessing the api_tokens API paths: API tokens allow users to call the API outside of their session token that is used as a cookie in the user interface.

kittycad.api.apps

Contains methods for accessing the apps API paths: Endpoints for third party app grant flows.

kittycad.api.beta

Contains methods for accessing the beta API paths: Beta API endpoints.

kittycad.api.constant

Contains methods for accessing the constant API paths: Constants.

kittycad.api.executor

Contains methods for accessing the executor API paths: Endpoints that allow for code execution or creation of code execution environments.

kittycad.api.file

Contains methods for accessing the file API paths: CAD file operations.

kittycad.api.hidden

Contains methods for accessing the hidden API paths: Hidden API endpoints that should not show up in the docs.

kittycad.api.meta

Contains methods for accessing the meta API paths: Meta information about the API.

kittycad.api.modeling

Contains methods for accessing the modeling API paths: Modeling API for updating your 3D files using the KittyCAD engine.

kittycad.api.oauth2

Contains methods for accessing the oauth2 API paths: Endpoints that implement OAuth 2.0 grant flows.

kittycad.api.payments

Contains methods for accessing the payments API paths: Operations around payments and billing.

kittycad.api.unit

Contains methods for accessing the unit API paths: Unit conversion operations.

kittycad.api.users

Contains methods for accessing the users API paths: A user is someone who uses the KittyCAD API.

kittycad.api.ai.create_image_to_3d

kittycad.api.ai.create_text_to_3d

asyncio(input_format, output_format, body, ...)

This is an alpha endpoint.

asyncio_detailed(input_format, ...)

rtype

Response[Union[Mesh, Error, None]]

sync(input_format, output_format, body, *, ...)

sync_detailed(input_format, output_format, ...)

rtype

:py:obj:`asyncio <kittycad.api.ai.create_image_to_3d.asyncio>`\ \(input\_format\, output\_format\, body\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.ai.create_image_to_3d.asyncio_detailed>`\ \(input\_format\, ...\)

:py:obj:`sync <kittycad.api.ai.create_image_to_3d.sync>`\ \(input\_format\, output\_format\, body\, \*\, ...\)

:py:obj:`sync_detailed <kittycad.api.ai.create_image_to_3d.sync_detailed>`\ \(input\_format\, output\_format\, ...\)

_build_response() (in module kittycad.api.ai.create_image_to_3d)

_parse_response() (in module kittycad.api.ai.create_image_to_3d)

[<desc_sig_keyword: <#text: 'async'>>, <desc_sig_space: <#text: ' '>>]

This is an alpha endpoint. It will change in the future. The current output is honestly pretty bad. So if you find this endpoint, you get what you pay for, which currently is nothing. But in the future will be made a lot better.

asyncio_detailed() (in module kittycad.api.ai.create_image_to_3d)

asyncio(output_format, prompt, *, client)

asyncio_detailed(output_format, prompt, *, ...)

rtype

sync(output_format, prompt, *, client)

sync_detailed(output_format, prompt, *, client)

rtype

:py:obj:`asyncio <kittycad.api.ai.create_text_to_3d.asyncio>`\ \(output\_format\, prompt\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.ai.create_text_to_3d.asyncio_detailed>`\ \(output\_format\, prompt\, \*\, ...\)

:py:obj:`sync <kittycad.api.ai.create_text_to_3d.sync>`\ \(output\_format\, prompt\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.ai.create_text_to_3d.sync_detailed>`\ \(output\_format\, prompt\, \*\, client\)

asyncio_detailed() (in module kittycad.api.ai.create_text_to_3d)

Contains methods for accessing the api_calls API paths: API calls that have been performed by users can be queried by the API. This is helpful for debugging as well as billing.

kittycad.api.api_calls.get_api_call

kittycad.api.api_calls.get_api_call_for_user

kittycad.api.api_calls.get_api_call_metrics

kittycad.api.api_calls.get_async_operation

kittycad.api.api_calls.list_api_calls

kittycad.api.api_calls.list_api_calls_for_user

kittycad.api.api_calls.list_async_operations

kittycad.api.api_calls.user_list_api_calls

asyncio(id, *, client)

This endpoint requires authentication by any KittyCAD user.

asyncio_detailed(id, *, client)

rtype

Response[Union[ApiCallWithPrice, Error, None]]

sync(id, *, client)

sync_detailed(id, *, client)

rtype

:py:obj:`asyncio <kittycad.api.api_calls.get_api_call.asyncio>`\ \(id\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.get_api_call.asyncio_detailed>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.api_calls.get_api_call.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_calls.get_api_call.sync_detailed>`\ \(id\, \*\, client\)

_build_response() (in module kittycad.api.api_calls.get_api_call)

_parse_response() (in module kittycad.api.api_calls.get_api_call)

This endpoint requires authentication by any KittyCAD user. It returns details of the requested API call for the user.
If the user is not authenticated to view the specified API call, then it is not returned.
Only KittyCAD employees can view API calls for other users.

asyncio_detailed() (in module kittycad.api.api_calls.get_api_call)

:py:obj:`asyncio <kittycad.api.api_calls.get_api_call_for_user.asyncio>`\ \(id\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.get_api_call_for_user.asyncio_detailed>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.api_calls.get_api_call_for_user.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_calls.get_api_call_for_user.sync_detailed>`\ \(id\, \*\, client\)

_build_response() (in module kittycad.api.api_calls.get_api_call_for_user)

_get_kwargs() (in module kittycad.api.api_calls.get_api_call_for_user)

_parse_response() (in module kittycad.api.api_calls.get_api_call_for_user)

asyncio() (in module kittycad.api.api_calls.get_api_call_for_user)

asyncio_detailed() (in module kittycad.api.api_calls.get_api_call_for_user)

sync_detailed() (in module kittycad.api.api_calls.get_api_call_for_user)

asyncio(group_by, *, client)

This endpoint requires authentication by a KittyCAD employee.

asyncio_detailed(group_by, *, client)

rtype

Response[Union[List[ApiCallQueryGroup], Error, None]]

sync(group_by, *, client)

sync_detailed(group_by, *, client)

rtype

:py:obj:`asyncio <kittycad.api.api_calls.get_api_call_metrics.asyncio>`\ \(group\_by\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.get_api_call_metrics.asyncio_detailed>`\ \(group\_by\, \*\, client\)

:py:obj:`sync <kittycad.api.api_calls.get_api_call_metrics.sync>`\ \(group\_by\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_calls.get_api_call_metrics.sync_detailed>`\ \(group\_by\, \*\, client\)

_build_response() (in module kittycad.api.api_calls.get_api_call_metrics)

_get_kwargs() (in module kittycad.api.api_calls.get_api_call_metrics)

_parse_response() (in module kittycad.api.api_calls.get_api_call_metrics)

asyncio() (in module kittycad.api.api_calls.get_api_call_metrics)

This endpoint requires authentication by a KittyCAD employee. The API calls are grouped by the parameter passed.

asyncio_detailed() (in module kittycad.api.api_calls.get_api_call_metrics)

sync_detailed() (in module kittycad.api.api_calls.get_api_call_metrics)

Get the status and output of an async operation.

rtype

Response[Union[FileConversion, FileCenterOfMass, FileMass, FileVolume, FileDensity, FileSurfaceArea, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.api_calls.get_async_operation.asyncio>`\ \(id\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.get_async_operation.asyncio_detailed>`\ \(id\, \*\, client\)

rtype

:py:obj:`sync <kittycad.api.api_calls.get_async_operation.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_calls.get_async_operation.sync_detailed>`\ \(id\, \*\, client\)

_build_response() (in module kittycad.api.api_calls.get_async_operation)

_get_kwargs() (in module kittycad.api.api_calls.get_async_operation)

_parse_response() (in module kittycad.api.api_calls.get_async_operation)

Union[FileConversion, FileCenterOfMass, FileMass, FileVolume, FileDensity, FileSurfaceArea, Error, None]

asyncio() (in module kittycad.api.api_calls.get_async_operation)

This endpoint requires authentication by any KittyCAD user. It returns details of the requested async operation for the user.
If the user is not authenticated to view the specified async operation, then it is not returned.
Only KittyCAD employees with the proper access can view async operations for other users.

asyncio_detailed() (in module kittycad.api.api_calls.get_async_operation)

sync_detailed() (in module kittycad.api.api_calls.get_async_operation)

asyncio(sort_by, *, client[, limit, page_token])

asyncio_detailed(sort_by, *, client[, ...])

rtype

Response[Union[ApiCallWithPriceResultsPage, Error, None]]

sync(sort_by, *, client[, limit, page_token])

sync_detailed(sort_by, *, client[, limit, ...])

rtype

:py:obj:`asyncio <kittycad.api.api_calls.list_api_calls.asyncio>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.list_api_calls.asyncio_detailed>`\ \(sort\_by\, \*\, client\[\, ...\]\)

rtype

:py:obj:`sync <kittycad.api.api_calls.list_api_calls.sync>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.api_calls.list_api_calls.sync_detailed>`\ \(sort\_by\, \*\, client\[\, limit\, ...\]\)

_build_response() (in module kittycad.api.api_calls.list_api_calls)

_parse_response() (in module kittycad.api.api_calls.list_api_calls)

This endpoint requires authentication by a KittyCAD employee. The API calls are returned in order of creation, with the most recently created API calls first.

asyncio_detailed() (in module kittycad.api.api_calls.list_api_calls)

asyncio_detailed(sort_by, *, client, limit=None, page_token=None)

sync_detailed() (in module kittycad.api.api_calls.list_api_calls)

asyncio(id, sort_by, *, client[, limit, ...])

asyncio_detailed(id, sort_by, *, client[, ...])

rtype

sync(id, sort_by, *, client[, limit, page_token])

sync_detailed(id, sort_by, *, client[, ...])

rtype

:py:obj:`asyncio <kittycad.api.api_calls.list_api_calls_for_user.asyncio>`\ \(id\, sort\_by\, \*\, client\[\, limit\, ...\]\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.list_api_calls_for_user.asyncio_detailed>`\ \(id\, sort\_by\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.api_calls.list_api_calls_for_user.sync>`\ \(id\, sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.api_calls.list_api_calls_for_user.sync_detailed>`\ \(id\, sort\_by\, \*\, client\[\, ...\]\)

_build_response() (in module kittycad.api.api_calls.list_api_calls_for_user)

_get_kwargs() (in module kittycad.api.api_calls.list_api_calls_for_user)

_get_kwargs(id, sort_by, *, client, limit=None, page_token=None)

_parse_response() (in module kittycad.api.api_calls.list_api_calls_for_user)

asyncio() (in module kittycad.api.api_calls.list_api_calls_for_user)

This endpoint requires authentication by any KittyCAD user. It returns the API calls for the authenticated user if "me" is passed as the user id.
Alternatively, you can use the `/user/api-calls` endpoint to get the API calls for your user.
If the authenticated user is a KittyCAD employee, then the API calls are returned for the user specified by the user id.
The API calls are returned in order of creation, with the most recently created API calls first.

This endpoint requires authentication by any KittyCAD user. It returns the API calls for the authenticated user if “me” is passed as the user id.
Alternatively, you can use the 

 endpoint to get the API calls for your user.

asyncio_detailed() (in module kittycad.api.api_calls.list_api_calls_for_user)

asyncio_detailed(id, sort_by, *, client, limit=None, page_token=None)

sync() (in module kittycad.api.api_calls.list_api_calls_for_user)

sync_detailed() (in module kittycad.api.api_calls.list_api_calls_for_user)

sync_detailed(id, sort_by, *, client, limit=None, page_token=None)

asyncio(sort_by, status, *, client[, limit, ...])

For async file conversion operations, this endpoint does not return the contents of converted files (output).

asyncio_detailed(sort_by, status, *, client)

rtype

Response[Union[AsyncApiCallResultsPage, Error, None]]

sync(sort_by, status, *, client[, limit, ...])

sync_detailed(sort_by, status, *, client[, ...])

rtype

:py:obj:`asyncio <kittycad.api.api_calls.list_async_operations.asyncio>`\ \(sort\_by\, status\, \*\, client\[\, limit\, ...\]\)

For async file conversion operations, this endpoint does not return the contents of converted files (`output`).

For async file conversion operations, this endpoint does not return the contents of converted files (

:py:obj:`asyncio_detailed <kittycad.api.api_calls.list_async_operations.asyncio_detailed>`\ \(sort\_by\, status\, \*\, client\)

:py:obj:`sync <kittycad.api.api_calls.list_async_operations.sync>`\ \(sort\_by\, status\, \*\, client\[\, limit\, ...\]\)

:py:obj:`sync_detailed <kittycad.api.api_calls.list_async_operations.sync_detailed>`\ \(sort\_by\, status\, \*\, client\[\, ...\]\)

_build_response() (in module kittycad.api.api_calls.list_async_operations)

_get_kwargs() (in module kittycad.api.api_calls.list_async_operations)

_get_kwargs(sort_by, status, *, client, limit=None, page_token=None)

_parse_response() (in module kittycad.api.api_calls.list_async_operations)

asyncio() (in module kittycad.api.api_calls.list_async_operations)

asyncio(sort_by, status, *, client, limit=None, page_token=None)

For async file conversion operations, this endpoint does not return the contents of converted files (`output`). To get the contents use the `/async/operations/{id}` endpoint.

 endpoint.

asyncio_detailed() (in module kittycad.api.api_calls.list_async_operations)

asyncio_detailed(sort_by, status, *, client, limit=None, page_token=None)

sync_detailed() (in module kittycad.api.api_calls.list_async_operations)

sync_detailed(sort_by, status, *, client, limit=None, page_token=None)

rtype

rtype

:py:obj:`asyncio <kittycad.api.api_calls.user_list_api_calls.asyncio>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`asyncio_detailed <kittycad.api.api_calls.user_list_api_calls.asyncio_detailed>`\ \(sort\_by\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.api_calls.user_list_api_calls.sync>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.api_calls.user_list_api_calls.sync_detailed>`\ \(sort\_by\, \*\, client\[\, limit\, ...\]\)

_build_response() (in module kittycad.api.api_calls.user_list_api_calls)

_get_kwargs() (in module kittycad.api.api_calls.user_list_api_calls)

_parse_response() (in module kittycad.api.api_calls.user_list_api_calls)

asyncio() (in module kittycad.api.api_calls.user_list_api_calls)

This endpoint requires authentication by any KittyCAD user. It returns the API calls for the authenticated user.

asyncio_detailed() (in module kittycad.api.api_calls.user_list_api_calls)

sync_detailed() (in module kittycad.api.api_calls.user_list_api_calls)

Contains methods for accessing the api_tokens API paths: API tokens allow users to call the API outside of their session token that is used as a cookie in the user interface. Users can create, delete, and list their API tokens. But, of course, you need an API token to do this, so first be sure to generate one in the account UI.

kittycad.api.api_tokens.create_api_token_for_user

kittycad.api.api_tokens.delete_api_token_for_user

kittycad.api.api_tokens.get_api_token_for_user

kittycad.api.api_tokens.list_api_tokens_for_user

asyncio(*, client)

asyncio_detailed(*, client)

rtype

Response[Union[ApiToken, Error, None]]

sync(*, client)

sync_detailed(*, client)

rtype

:py:obj:`asyncio <kittycad.api.api_tokens.create_api_token_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_tokens.create_api_token_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.api_tokens.create_api_token_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_tokens.create_api_token_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.api_tokens.create_api_token_for_user)

_get_kwargs() (in module kittycad.api.api_tokens.create_api_token_for_user)

_parse_response() (in module kittycad.api.api_tokens.create_api_token_for_user)

asyncio() (in module kittycad.api.api_tokens.create_api_token_for_user)

This endpoint requires authentication by any KittyCAD user. It creates a new API token for the authenticated user.

asyncio_detailed() (in module kittycad.api.api_tokens.create_api_token_for_user)

sync() (in module kittycad.api.api_tokens.create_api_token_for_user)

sync_detailed() (in module kittycad.api.api_tokens.create_api_token_for_user)

asyncio(token, *, client)

asyncio_detailed(token, *, client)

rtype

Response[Optional[Error]]

sync(token, *, client)

sync_detailed(token, *, client)

rtype

:py:obj:`asyncio <kittycad.api.api_tokens.delete_api_token_for_user.asyncio>`\ \(token\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_tokens.delete_api_token_for_user.asyncio_detailed>`\ \(token\, \*\, client\)

:py:obj:`sync <kittycad.api.api_tokens.delete_api_token_for_user.sync>`\ \(token\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_tokens.delete_api_token_for_user.sync_detailed>`\ \(token\, \*\, client\)

_build_response() (in module kittycad.api.api_tokens.delete_api_token_for_user)

_get_kwargs() (in module kittycad.api.api_tokens.delete_api_token_for_user)

_parse_response() (in module kittycad.api.api_tokens.delete_api_token_for_user)

asyncio() (in module kittycad.api.api_tokens.delete_api_token_for_user)

This endpoint requires authentication by any KittyCAD user. It deletes the requested API token for the user.
This endpoint does not actually delete the API token from the database. It merely marks the token as invalid. We still want to keep the token in the database for historical purposes.

asyncio_detailed() (in module kittycad.api.api_tokens.delete_api_token_for_user)

sync() (in module kittycad.api.api_tokens.delete_api_token_for_user)

sync_detailed() (in module kittycad.api.api_tokens.delete_api_token_for_user)

rtype

rtype

:py:obj:`asyncio <kittycad.api.api_tokens.get_api_token_for_user.asyncio>`\ \(token\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.api_tokens.get_api_token_for_user.asyncio_detailed>`\ \(token\, \*\, client\)

:py:obj:`sync <kittycad.api.api_tokens.get_api_token_for_user.sync>`\ \(token\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.api_tokens.get_api_token_for_user.sync_detailed>`\ \(token\, \*\, client\)

_build_response() (in module kittycad.api.api_tokens.get_api_token_for_user)

_get_kwargs() (in module kittycad.api.api_tokens.get_api_token_for_user)

_parse_response() (in module kittycad.api.api_tokens.get_api_token_for_user)

asyncio() (in module kittycad.api.api_tokens.get_api_token_for_user)

This endpoint requires authentication by any KittyCAD user. It returns details of the requested API token for the user.

asyncio_detailed() (in module kittycad.api.api_tokens.get_api_token_for_user)

sync() (in module kittycad.api.api_tokens.get_api_token_for_user)

sync_detailed() (in module kittycad.api.api_tokens.get_api_token_for_user)

rtype

Response[Union[ApiTokenResultsPage, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.api_tokens.list_api_tokens_for_user.asyncio>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`asyncio_detailed <kittycad.api.api_tokens.list_api_tokens_for_user.asyncio_detailed>`\ \(sort\_by\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.api_tokens.list_api_tokens_for_user.sync>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.api_tokens.list_api_tokens_for_user.sync_detailed>`\ \(sort\_by\, \*\, client\[\, limit\, ...\]\)

_build_response() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

_get_kwargs() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

_parse_response() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

asyncio() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

This endpoint requires authentication by any KittyCAD user. It returns the API tokens for the authenticated user.
The API tokens are returned in order of creation, with the most recently created API tokens first.

asyncio_detailed() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

sync() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

sync_detailed() (in module kittycad.api.api_tokens.list_api_tokens_for_user)

kittycad.api.apps.apps_github_callback

kittycad.api.apps.apps_github_consent

kittycad.api.apps.apps_github_webhook

This is different than OAuth 2.0 authentication for users.

rtype

rtype

:py:obj:`asyncio <kittycad.api.apps.apps_github_callback.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.apps.apps_github_callback.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.apps.apps_github_callback.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.apps.apps_github_callback.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.apps.apps_github_callback)

_get_kwargs() (in module kittycad.api.apps.apps_github_callback)

_parse_response() (in module kittycad.api.apps.apps_github_callback)

This is different than OAuth 2.0 authentication for users. This endpoint grants access for KittyCAD to access user's repos.
The user doesn't need KittyCAD OAuth authorization for this endpoint, this is purely for the GitHub permissions to access repos.

This is different than OAuth 2.0 authentication for users. This endpoint grants access for KittyCAD to access user’s repos.
The user doesn’t need KittyCAD OAuth authorization for this endpoint, this is purely for the GitHub permissions to access repos.

asyncio_detailed() (in module kittycad.api.apps.apps_github_callback)

sync_detailed() (in module kittycad.api.apps.apps_github_callback)

rtype

Response[Union[AppClientInfo, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.apps.apps_github_consent.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.apps.apps_github_consent.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.apps.apps_github_consent.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.apps.apps_github_consent.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.apps.apps_github_consent)

_parse_response() (in module kittycad.api.apps.apps_github_consent)

asyncio_detailed() (in module kittycad.api.apps.apps_github_consent)

sync_detailed() (in module kittycad.api.apps.apps_github_consent)

asyncio(body, *, client)

These come from the GitHub app.

asyncio_detailed(body, *, client)

rtype

sync(body, *, client)

sync_detailed(body, *, client)

rtype

:py:obj:`asyncio <kittycad.api.apps.apps_github_webhook.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.apps.apps_github_webhook.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.apps.apps_github_webhook.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.apps.apps_github_webhook.sync_detailed>`\ \(body\, \*\, client\)

_build_response() (in module kittycad.api.apps.apps_github_webhook)

_parse_response() (in module kittycad.api.apps.apps_github_webhook)

asyncio_detailed() (in module kittycad.api.apps.apps_github_webhook)

sync_detailed() (in module kittycad.api.apps.apps_github_webhook)

Contains methods for accessing the beta API paths: Beta API endpoints. We will not charge for these endpoints while they are in beta.

Contains methods for accessing the constant API paths: Constants. These are helpful as helpers.

kittycad.api.executor.create_executor_term

kittycad.api.executor.create_file_execution

Attach to a docker container to create an interactive terminal.

:py:obj:`asyncio <kittycad.api.executor.create_executor_term.asyncio>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.executor.create_executor_term.sync>`\ \(\*\, client\)

_get_kwargs() (in module kittycad.api.executor.create_executor_term)

asyncio() (in module kittycad.api.executor.create_executor_term)

asyncio(lang, body, *, client[, output])

rtype

Union[CodeOutput, Error, None]

asyncio_detailed(lang, body, *, client[, output])

rtype

Response[Union[CodeOutput, Error, None]]

sync(lang, body, *, client[, output])

rtype

sync_detailed(lang, body, *, client[, output])

rtype

:py:obj:`asyncio <kittycad.api.executor.create_file_execution.asyncio>`\ \(lang\, body\, \*\, client\[\, output\]\)

:py:obj:`asyncio_detailed <kittycad.api.executor.create_file_execution.asyncio_detailed>`\ \(lang\, body\, \*\, client\[\, output\]\)

:py:obj:`sync <kittycad.api.executor.create_file_execution.sync>`\ \(lang\, body\, \*\, client\[\, output\]\)

:py:obj:`sync_detailed <kittycad.api.executor.create_file_execution.sync_detailed>`\ \(lang\, body\, \*\, client\[\, output\]\)

_build_response() (in module kittycad.api.executor.create_file_execution)

_get_kwargs() (in module kittycad.api.executor.create_file_execution)

_parse_response() (in module kittycad.api.executor.create_file_execution)

asyncio() (in module kittycad.api.executor.create_file_execution)

asyncio_detailed() (in module kittycad.api.executor.create_file_execution)

sync_detailed() (in module kittycad.api.executor.create_file_execution)

Contains methods for accessing the file API paths: CAD file operations. Create, get, and list CAD file conversions. More endpoints will be added here in the future as we build out transforms, etc on CAD models.

kittycad.api.file.create_file_center_of_mass

kittycad.api.file.create_file_conversion

kittycad.api.file.create_file_conversion_with_base64_helper

kittycad.api.file.create_file_density

kittycad.api.file.create_file_mass

kittycad.api.file.create_file_surface_area

kittycad.api.file.create_file_volume

kittycad.api.file.get_file_conversion_with_base64_helper

asyncio(output_unit, src_format, body, *, client)

We assume any file given to us has one consistent unit throughout.

asyncio_detailed(output_unit, src_format, ...)

rtype

Response[Union[FileCenterOfMass, Error, None]]

sync(output_unit, src_format, body, *, client)

sync_detailed(output_unit, src_format, body, ...)

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_center_of_mass.asyncio>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_center_of_mass.asyncio_detailed>`\ \(output\_unit\, src\_format\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_center_of_mass.sync>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_center_of_mass.sync_detailed>`\ \(output\_unit\, src\_format\, body\, ...\)

_build_response() (in module kittycad.api.file.create_file_center_of_mass)

_get_kwargs() (in module kittycad.api.file.create_file_center_of_mass)

_parse_response() (in module kittycad.api.file.create_file_center_of_mass)

asyncio() (in module kittycad.api.file.create_file_center_of_mass)

We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
This endpoint returns the cartesian co-ordinate in world space measure units.
In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
Get the center of mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.

If the operation is performed asynchronously, the 

 returned from the request to get status information about the async operation from the 

asyncio_detailed() (in module kittycad.api.file.create_file_center_of_mass)

sync_detailed() (in module kittycad.api.file.create_file_center_of_mass)

asyncio(output_format, src_format, body, *, ...)

If you wish to specify the conversion options, use the /file/conversion endpoint instead.

asyncio_detailed(output_format, src_format, ...)

rtype

Response[Union[FileConversion, Error, None]]

sync(output_format, src_format, body, *, client)

sync_detailed(output_format, src_format, ...)

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_conversion.asyncio>`\ \(output\_format\, src\_format\, body\, \*\, ...\)

If you wish to specify the conversion options, use the `/file/conversion` endpoint instead.

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_conversion.asyncio_detailed>`\ \(output\_format\, src\_format\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_conversion.sync>`\ \(output\_format\, src\_format\, body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_conversion.sync_detailed>`\ \(output\_format\, src\_format\, ...\)

_build_response() (in module kittycad.api.file.create_file_conversion)

_get_kwargs() (in module kittycad.api.file.create_file_conversion)

_parse_response() (in module kittycad.api.file.create_file_conversion)

Convert a CAD file from one format to another. If the file being converted is larger than 25MB, it will be performed asynchronously.
If the conversion is performed synchronously, the contents of the converted file (`output`) will be returned as a base64 encoded string.

 endpoint instead.
If the conversion is performed synchronously, the contents of the converted file (

) will be returned as a base64 encoded string.

asyncio_detailed() (in module kittycad.api.file.create_file_conversion)

sync_detailed() (in module kittycad.api.file.create_file_conversion)

asyncio(src_format, output_format, body, *, ...)

Convert a CAD file from one format to another.

sync(src_format, output_format, body, *, client)

:py:obj:`asyncio <kittycad.api.file.create_file_conversion_with_base64_helper.asyncio>`\ \(src\_format\, output\_format\, body\, \*\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_conversion_with_base64_helper.sync>`\ \(src\_format\, output\_format\, body\, \*\, client\)

asyncio() (in module kittycad.api.file.create_file_conversion_with_base64_helper)

Convert a CAD file from one format to another. If the file being converted is larger than a certain size it will be performed asynchronously. This function automatically base64 encodes the request body and base64 decodes the request output.

sync() (in module kittycad.api.file.create_file_conversion_with_base64_helper)

asyncio(material_mass, material_mass_unit, ...)

asyncio_detailed(material_mass, ...)

rtype

Response[Union[FileDensity, Error, None]]

sync(material_mass, material_mass_unit, ...)

sync_detailed(material_mass, ...)

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_density.asyncio>`\ \(material\_mass\, material\_mass\_unit\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_density.asyncio_detailed>`\ \(material\_mass\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_density.sync>`\ \(material\_mass\, material\_mass\_unit\, ...\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_density.sync_detailed>`\ \(material\_mass\, ...\)

_build_response() (in module kittycad.api.file.create_file_density)

_get_kwargs(material_mass, material_mass_unit, output_unit, src_format, body, *, client)

material_mass, material_mass_unit, output_unit, src_format, body, *, client

_parse_response() (in module kittycad.api.file.create_file_density)

asyncio(material_mass, material_mass_unit, output_unit, src_format, body, *, client)

This endpoint assumes if you are giving a material mass in a specific mass units, we return a density in mass unit per cubic measure unit.
Get the density of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

asyncio_detailed() (in module kittycad.api.file.create_file_density)

asyncio_detailed(material_mass, material_mass_unit, output_unit, src_format, body, *, client)

sync(material_mass, material_mass_unit, output_unit, src_format, body, *, client)

sync_detailed() (in module kittycad.api.file.create_file_density)

sync_detailed(material_mass, material_mass_unit, output_unit, src_format, body, *, client)

asyncio(material_density, ...)

asyncio_detailed(material_density, ...)

rtype

Response[Union[FileMass, Error, None]]

sync(material_density, ...)

sync_detailed(material_density, ...)

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_mass.asyncio>`\ \(material\_density\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_mass.asyncio_detailed>`\ \(material\_density\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_mass.sync>`\ \(material\_density\, ...\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_mass.sync_detailed>`\ \(material\_density\, ...\)

_build_response() (in module kittycad.api.file.create_file_mass)

_get_kwargs(material_density, material_density_unit, output_unit, src_format, body, *, client)

material_density, material_density_unit, output_unit, src_format, body, *, client

_parse_response() (in module kittycad.api.file.create_file_mass)

asyncio(material_density, material_density_unit, output_unit, src_format, body, *, client)

This endpoint assumes if you are giving a material density in a specific mass unit per cubic measure unit, we return a mass in mass units. The same mass units as passed in the material density.
Get the mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

asyncio_detailed() (in module kittycad.api.file.create_file_mass)

asyncio_detailed(material_density, material_density_unit, output_unit, src_format, body, *, client)

sync(material_density, material_density_unit, output_unit, src_format, body, *, client)

sync_detailed(material_density, material_density_unit, output_unit, src_format, body, *, client)

rtype

Response[Union[FileSurfaceArea, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_surface_area.asyncio>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_surface_area.asyncio_detailed>`\ \(output\_unit\, src\_format\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_surface_area.sync>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_surface_area.sync_detailed>`\ \(output\_unit\, src\_format\, body\, ...\)

_build_response() (in module kittycad.api.file.create_file_surface_area)

_get_kwargs() (in module kittycad.api.file.create_file_surface_area)

_parse_response() (in module kittycad.api.file.create_file_surface_area)

asyncio() (in module kittycad.api.file.create_file_surface_area)

This endpoint returns the square measure units.
Get the surface area of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

asyncio_detailed() (in module kittycad.api.file.create_file_surface_area)

sync_detailed() (in module kittycad.api.file.create_file_surface_area)

rtype

Response[Union[FileVolume, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.file.create_file_volume.asyncio>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.file.create_file_volume.asyncio_detailed>`\ \(output\_unit\, src\_format\, ...\)

:py:obj:`sync <kittycad.api.file.create_file_volume.sync>`\ \(output\_unit\, src\_format\, body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.file.create_file_volume.sync_detailed>`\ \(output\_unit\, src\_format\, body\, ...\)

_build_response() (in module kittycad.api.file.create_file_volume)

_parse_response() (in module kittycad.api.file.create_file_volume)

This endpoint returns the cubic measure units.
Get the volume of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

asyncio_detailed() (in module kittycad.api.file.create_file_volume)

sync_detailed() (in module kittycad.api.file.create_file_volume)

Get the status of a file conversion.

:py:obj:`asyncio <kittycad.api.file.get_file_conversion_with_base64_helper.asyncio>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.file.get_file_conversion_with_base64_helper.sync>`\ \(id\, \*\, client\)

asyncio() (in module kittycad.api.file.get_file_conversion_with_base64_helper)

Get the status of a file conversion. This function automatically base64 decodes the output response if there is one.

sync() (in module kittycad.api.file.get_file_conversion_with_base64_helper)

kittycad.api.hidden.auth_email

kittycad.api.hidden.auth_email_callback

kittycad.api.hidden.logout

rtype

Union[VerificationToken, Error, None]

rtype

Response[Union[VerificationToken, Error, None]]

rtype

rtype

:py:obj:`asyncio <kittycad.api.hidden.auth_email.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.hidden.auth_email.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.hidden.auth_email.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.hidden.auth_email.sync_detailed>`\ \(body\, \*\, client\)

asyncio(email, token, *, client[, callback_url])

rtype

Optional[Error]

asyncio_detailed(email, token, *, client[, ...])

rtype

sync(email, token, *, client[, callback_url])

rtype

sync_detailed(email, token, *, client[, ...])

rtype

:py:obj:`asyncio <kittycad.api.hidden.auth_email_callback.asyncio>`\ \(email\, token\, \*\, client\[\, callback\_url\]\)

:py:obj:`asyncio_detailed <kittycad.api.hidden.auth_email_callback.asyncio_detailed>`\ \(email\, token\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.hidden.auth_email_callback.sync>`\ \(email\, token\, \*\, client\[\, callback\_url\]\)

:py:obj:`sync_detailed <kittycad.api.hidden.auth_email_callback.sync_detailed>`\ \(email\, token\, \*\, client\[\, ...\]\)

_build_response() (in module kittycad.api.hidden.auth_email_callback)

_get_kwargs() (in module kittycad.api.hidden.auth_email_callback)

_parse_response() (in module kittycad.api.hidden.auth_email_callback)

asyncio_detailed() (in module kittycad.api.hidden.auth_email_callback)

sync_detailed() (in module kittycad.api.hidden.auth_email_callback)

This is used in logout scenarios.

rtype

rtype

:py:obj:`asyncio <kittycad.api.hidden.logout.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.hidden.logout.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.hidden.logout.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.hidden.logout.sync_detailed>`\ \(\*\, client\)

kittycad.api.meta.get_ai_plugin_manifest

kittycad.api.meta.get_metadata

kittycad.api.meta.get_openai_schema

kittycad.api.meta.get_schema

kittycad.api.meta.ping

rtype

Union[AiPluginManifest, Error, None]

rtype

Response[Union[AiPluginManifest, Error, None]]

rtype

rtype

:py:obj:`asyncio <kittycad.api.meta.get_ai_plugin_manifest.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.meta.get_ai_plugin_manifest.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.meta.get_ai_plugin_manifest.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.meta.get_ai_plugin_manifest.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.meta.get_ai_plugin_manifest)

_get_kwargs() (in module kittycad.api.meta.get_ai_plugin_manifest)

_parse_response() (in module kittycad.api.meta.get_ai_plugin_manifest)

asyncio_detailed() (in module kittycad.api.meta.get_ai_plugin_manifest)

sync_detailed() (in module kittycad.api.meta.get_ai_plugin_manifest)

This includes information on any of our other distributed systems it is connected to.

rtype

Response[Union[Metadata, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.meta.get_metadata.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.meta.get_metadata.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.meta.get_metadata.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.meta.get_metadata.sync_detailed>`\ \(\*\, client\)

You must be a KittyCAD employee to perform this request.

This is the same as the OpenAPI schema, BUT it has some modifications to make it compatible with OpenAI.

rtype

Response[Union[dict, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.meta.get_openai_schema.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.meta.get_openai_schema.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.meta.get_openai_schema.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.meta.get_openai_schema.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.meta.get_openai_schema)

_parse_response() (in module kittycad.api.meta.get_openai_schema)

This is the same as the OpenAPI schema, BUT it has some modifications to make it compatible with OpenAI. For example, descriptions must be < 300 chars.

asyncio_detailed() (in module kittycad.api.meta.get_openai_schema)

rtype

Union[dict, Error, None]

rtype

rtype

rtype

:py:obj:`asyncio <kittycad.api.meta.get_schema.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.meta.get_schema.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.meta.get_schema.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.meta.get_schema.sync_detailed>`\ \(\*\, client\)

rtype

Union[Pong, Error, None]

rtype

Response[Union[Pong, Error, None]]

rtype

rtype

:py:obj:`asyncio <kittycad.api.meta.ping.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.meta.ping.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.meta.ping.sync_detailed>`\ \(\*\, client\)

kittycad.api.modeling.cmd

kittycad.api.modeling.cmd_batch

kittycad.api.modeling.modeling_commands_ws

Response depends on which command was submitted, so unfortunately the OpenAPI schema can't generate the right response type.

rtype

rtype

:py:obj:`asyncio <kittycad.api.modeling.cmd.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.modeling.cmd.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.modeling.cmd.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.modeling.cmd.sync_detailed>`\ \(body\, \*\, client\)

Response depends on which command was submitted, so unfortunately the OpenAPI schema can’t generate the right response type.

rtype

Union[ModelingOutcomes, Error, None]

rtype

Response[Union[ModelingOutcomes, Error, None]]

rtype

rtype

:py:obj:`asyncio <kittycad.api.modeling.cmd_batch.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.modeling.cmd_batch.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.modeling.cmd_batch.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.modeling.cmd_batch.sync_detailed>`\ \(body\, \*\, client\)

asyncio(fps, unlocked_framerate, ...)

Pass those commands to the engine via websocket, and pass responses back to the client.

sync(fps, unlocked_framerate, ...)

:py:obj:`asyncio <kittycad.api.modeling.modeling_commands_ws.asyncio>`\ \(fps\, unlocked\_framerate\, ...\)

:py:obj:`sync <kittycad.api.modeling.modeling_commands_ws.sync>`\ \(fps\, unlocked\_framerate\, ...\)

_get_kwargs() (in module kittycad.api.modeling.modeling_commands_ws)

_get_kwargs(fps, unlocked_framerate, video_res_height, video_res_width, *, client)

fps, unlocked_framerate, video_res_height, video_res_width, *, client

asyncio() (in module kittycad.api.modeling.modeling_commands_ws)

asyncio(fps, unlocked_framerate, video_res_height, video_res_width, *, client)

Pass those commands to the engine via websocket, and pass responses back to the client. Basically, this is a websocket proxy between the frontend/client and the engine.

sync(fps, unlocked_framerate, video_res_height, video_res_width, *, client)

kittycad.api.payments.create_payment_information_for_user

kittycad.api.payments.create_payment_intent_for_user

kittycad.api.payments.delete_payment_information_for_user

kittycad.api.payments.delete_payment_method_for_user

kittycad.api.payments.get_payment_balance_for_user

kittycad.api.payments.get_payment_information_for_user

kittycad.api.payments.list_invoices_for_user

kittycad.api.payments.list_payment_methods_for_user

kittycad.api.payments.update_payment_information_for_user

kittycad.api.payments.validate_customer_tax_information_for_user

This includes billing address, phone, and name.

rtype

Response[Union[Customer, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.payments.create_payment_information_for_user.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.create_payment_information_for_user.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.payments.create_payment_information_for_user.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.create_payment_information_for_user.sync_detailed>`\ \(body\, \*\, client\)

_build_response() (in module kittycad.api.payments.create_payment_information_for_user)

_get_kwargs() (in module kittycad.api.payments.create_payment_information_for_user)

_parse_response() (in module kittycad.api.payments.create_payment_information_for_user)

asyncio() (in module kittycad.api.payments.create_payment_information_for_user)

This endpoint requires authentication by any KittyCAD user. It creates the payment information for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.create_payment_information_for_user)

sync() (in module kittycad.api.payments.create_payment_information_for_user)

sync_detailed() (in module kittycad.api.payments.create_payment_information_for_user)

rtype

Response[Union[PaymentIntent, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.payments.create_payment_intent_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.create_payment_intent_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.create_payment_intent_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.create_payment_intent_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.create_payment_intent_for_user)

_get_kwargs() (in module kittycad.api.payments.create_payment_intent_for_user)

_parse_response() (in module kittycad.api.payments.create_payment_intent_for_user)

asyncio() (in module kittycad.api.payments.create_payment_intent_for_user)

This endpoint requires authentication by any KittyCAD user. It creates a new payment intent for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.create_payment_intent_for_user)

sync() (in module kittycad.api.payments.create_payment_intent_for_user)

sync_detailed() (in module kittycad.api.payments.create_payment_intent_for_user)

rtype

rtype

:py:obj:`asyncio <kittycad.api.payments.delete_payment_information_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.delete_payment_information_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.delete_payment_information_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.delete_payment_information_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.delete_payment_information_for_user)

_get_kwargs() (in module kittycad.api.payments.delete_payment_information_for_user)

_parse_response() (in module kittycad.api.payments.delete_payment_information_for_user)

asyncio() (in module kittycad.api.payments.delete_payment_information_for_user)

This endpoint requires authentication by any KittyCAD user. It deletes the payment information for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.delete_payment_information_for_user)

sync() (in module kittycad.api.payments.delete_payment_information_for_user)

sync_detailed() (in module kittycad.api.payments.delete_payment_information_for_user)

rtype

rtype

:py:obj:`asyncio <kittycad.api.payments.delete_payment_method_for_user.asyncio>`\ \(id\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.delete_payment_method_for_user.asyncio_detailed>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.payments.delete_payment_method_for_user.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.delete_payment_method_for_user.sync_detailed>`\ \(id\, \*\, client\)

_build_response() (in module kittycad.api.payments.delete_payment_method_for_user)

_get_kwargs() (in module kittycad.api.payments.delete_payment_method_for_user)

_parse_response() (in module kittycad.api.payments.delete_payment_method_for_user)

asyncio() (in module kittycad.api.payments.delete_payment_method_for_user)

This endpoint requires authentication by any KittyCAD user. It deletes the specified payment method for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.delete_payment_method_for_user)

sync() (in module kittycad.api.payments.delete_payment_method_for_user)

sync_detailed() (in module kittycad.api.payments.delete_payment_method_for_user)

rtype

Response[Union[CustomerBalance, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.payments.get_payment_balance_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.get_payment_balance_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.get_payment_balance_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.get_payment_balance_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.get_payment_balance_for_user)

_get_kwargs() (in module kittycad.api.payments.get_payment_balance_for_user)

_parse_response() (in module kittycad.api.payments.get_payment_balance_for_user)

asyncio() (in module kittycad.api.payments.get_payment_balance_for_user)

This endpoint requires authentication by any KittyCAD user. It gets the balance information for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.get_payment_balance_for_user)

sync() (in module kittycad.api.payments.get_payment_balance_for_user)

sync_detailed() (in module kittycad.api.payments.get_payment_balance_for_user)

rtype

rtype

:py:obj:`asyncio <kittycad.api.payments.get_payment_information_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.get_payment_information_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.get_payment_information_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.get_payment_information_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.get_payment_information_for_user)

_get_kwargs() (in module kittycad.api.payments.get_payment_information_for_user)

_parse_response() (in module kittycad.api.payments.get_payment_information_for_user)

asyncio() (in module kittycad.api.payments.get_payment_information_for_user)

This endpoint requires authentication by any KittyCAD user. It gets the payment information for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.get_payment_information_for_user)

sync() (in module kittycad.api.payments.get_payment_information_for_user)

sync_detailed() (in module kittycad.api.payments.get_payment_information_for_user)

rtype

Response[Union[List[Invoice], Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.payments.list_invoices_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.list_invoices_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.list_invoices_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.list_invoices_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.list_invoices_for_user)

_get_kwargs() (in module kittycad.api.payments.list_invoices_for_user)

_parse_response() (in module kittycad.api.payments.list_invoices_for_user)

asyncio() (in module kittycad.api.payments.list_invoices_for_user)

This endpoint requires authentication by any KittyCAD user. It lists invoices for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.list_invoices_for_user)

sync_detailed() (in module kittycad.api.payments.list_invoices_for_user)

rtype

Response[Union[List[PaymentMethod], Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.payments.list_payment_methods_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.list_payment_methods_for_user.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.list_payment_methods_for_user.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.list_payment_methods_for_user.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.list_payment_methods_for_user)

_get_kwargs() (in module kittycad.api.payments.list_payment_methods_for_user)

_parse_response() (in module kittycad.api.payments.list_payment_methods_for_user)

asyncio() (in module kittycad.api.payments.list_payment_methods_for_user)

This endpoint requires authentication by any KittyCAD user. It lists payment methods for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.list_payment_methods_for_user)

sync() (in module kittycad.api.payments.list_payment_methods_for_user)

sync_detailed() (in module kittycad.api.payments.list_payment_methods_for_user)

:py:obj:`asyncio <kittycad.api.payments.update_payment_information_for_user.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.payments.update_payment_information_for_user.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.payments.update_payment_information_for_user.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.payments.update_payment_information_for_user.sync_detailed>`\ \(body\, \*\, client\)

_build_response() (in module kittycad.api.payments.update_payment_information_for_user)

_get_kwargs() (in module kittycad.api.payments.update_payment_information_for_user)

_parse_response() (in module kittycad.api.payments.update_payment_information_for_user)

asyncio() (in module kittycad.api.payments.update_payment_information_for_user)

This endpoint requires authentication by any KittyCAD user. It updates the payment information for the authenticated user.

asyncio_detailed() (in module kittycad.api.payments.update_payment_information_for_user)

sync() (in module kittycad.api.payments.update_payment_information_for_user)

sync_detailed() (in module kittycad.api.payments.update_payment_information_for_user)

rtype

rtype

:py:obj:`asyncio <kittycad.api.payments.validate_customer_tax_information_for_user.asyncio>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.payments.validate_customer_tax_information_for_user.sync>`\ \(\*\, client\)

_build_response() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

_get_kwargs() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

_parse_response() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

asyncio() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

This endpoint requires authentication by any KittyCAD user. It will return an error if the customer's information is not valid for automatic tax. Otherwise, it will return an empty successful response.

This endpoint requires authentication by any KittyCAD user. It will return an error if the customer’s information is not valid for automatic tax. Otherwise, it will return an empty successful response.

asyncio_detailed() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

sync() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

sync_detailed() (in module kittycad.api.payments.validate_customer_tax_information_for_user)

kittycad.api.unit.get_angle_unit_conversion

kittycad.api.unit.get_area_unit_conversion

kittycad.api.unit.get_current_unit_conversion

kittycad.api.unit.get_energy_unit_conversion

kittycad.api.unit.get_force_unit_conversion

kittycad.api.unit.get_frequency_unit_conversion

kittycad.api.unit.get_length_unit_conversion

kittycad.api.unit.get_mass_unit_conversion

kittycad.api.unit.get_power_unit_conversion

kittycad.api.unit.get_pressure_unit_conversion

kittycad.api.unit.get_temperature_unit_conversion

kittycad.api.unit.get_torque_unit_conversion

kittycad.api.unit.get_volume_unit_conversion

asyncio(input_unit, output_unit, value, *, ...)

Convert an angle unit value to another angle unit value.

asyncio_detailed(input_unit, output_unit, ...)

rtype

Response[Union[UnitAngleConversion, Error, None]]

sync(input_unit, output_unit, value, *, client)

sync_detailed(input_unit, output_unit, ...)

rtype

:py:obj:`asyncio <kittycad.api.unit.get_angle_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_angle_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_angle_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_angle_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_angle_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_angle_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_angle_unit_conversion)

asyncio() (in module kittycad.api.unit.get_angle_unit_conversion)

Convert an angle unit value to another angle unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_angle_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_angle_unit_conversion)

Convert an area unit value to another area unit value.

rtype

Response[Union[UnitAreaConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_area_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_area_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_area_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_area_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_area_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_area_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_area_unit_conversion)

asyncio() (in module kittycad.api.unit.get_area_unit_conversion)

Convert an area unit value to another area unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_area_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_area_unit_conversion)

Convert a current unit value to another current unit value.

rtype

Response[Union[UnitCurrentConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_current_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_current_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_current_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_current_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_current_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_current_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_current_unit_conversion)

asyncio() (in module kittycad.api.unit.get_current_unit_conversion)

Convert a current unit value to another current unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_current_unit_conversion)

sync() (in module kittycad.api.unit.get_current_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_current_unit_conversion)

Convert a energy unit value to another energy unit value.

rtype

Response[Union[UnitEnergyConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_energy_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_energy_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_energy_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_energy_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_energy_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_energy_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_energy_unit_conversion)

asyncio() (in module kittycad.api.unit.get_energy_unit_conversion)

Convert a energy unit value to another energy unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_energy_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_energy_unit_conversion)

Convert a force unit value to another force unit value.

rtype

Response[Union[UnitForceConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_force_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_force_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_force_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_force_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_force_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_force_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_force_unit_conversion)

asyncio() (in module kittycad.api.unit.get_force_unit_conversion)

Convert a force unit value to another force unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_force_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_force_unit_conversion)

Convert a frequency unit value to another frequency unit value.

rtype

Response[Union[UnitFrequencyConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_frequency_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_frequency_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_frequency_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_frequency_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_frequency_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_frequency_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_frequency_unit_conversion)

asyncio() (in module kittycad.api.unit.get_frequency_unit_conversion)

Convert a frequency unit value to another frequency unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_frequency_unit_conversion)

sync() (in module kittycad.api.unit.get_frequency_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_frequency_unit_conversion)

Convert a length unit value to another length unit value.

rtype

Response[Union[UnitLengthConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_length_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_length_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_length_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_length_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_length_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_length_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_length_unit_conversion)

asyncio() (in module kittycad.api.unit.get_length_unit_conversion)

Convert a length unit value to another length unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_length_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_length_unit_conversion)

Convert a mass unit value to another mass unit value.

rtype

Response[Union[UnitMassConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_mass_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_mass_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_mass_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_mass_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_mass_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_mass_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_mass_unit_conversion)

asyncio() (in module kittycad.api.unit.get_mass_unit_conversion)

Convert a mass unit value to another mass unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_mass_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_mass_unit_conversion)

Convert a power unit value to another power unit value.

rtype

Response[Union[UnitPowerConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_power_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_power_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_power_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_power_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_power_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_power_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_power_unit_conversion)

asyncio() (in module kittycad.api.unit.get_power_unit_conversion)

Convert a power unit value to another power unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_power_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_power_unit_conversion)

Convert a pressure unit value to another pressure unit value.

rtype

Response[Union[UnitPressureConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_pressure_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_pressure_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_pressure_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_pressure_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_pressure_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_pressure_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_pressure_unit_conversion)

asyncio() (in module kittycad.api.unit.get_pressure_unit_conversion)

Convert a pressure unit value to another pressure unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_pressure_unit_conversion)

sync() (in module kittycad.api.unit.get_pressure_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_pressure_unit_conversion)

Convert a temperature unit value to another temperature unit value.

rtype

Response[Union[UnitTemperatureConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_temperature_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_temperature_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_temperature_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_temperature_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_temperature_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_temperature_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_temperature_unit_conversion)

asyncio() (in module kittycad.api.unit.get_temperature_unit_conversion)

Convert a temperature unit value to another temperature unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_temperature_unit_conversion)

sync() (in module kittycad.api.unit.get_temperature_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_temperature_unit_conversion)

Convert a torque unit value to another torque unit value.

rtype

Response[Union[UnitTorqueConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_torque_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_torque_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_torque_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_torque_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_torque_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_torque_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_torque_unit_conversion)

asyncio() (in module kittycad.api.unit.get_torque_unit_conversion)

Convert a torque unit value to another torque unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_torque_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_torque_unit_conversion)

Convert a volume unit value to another volume unit value.

rtype

Response[Union[UnitVolumeConversion, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.unit.get_volume_unit_conversion.asyncio>`\ \(input\_unit\, output\_unit\, value\, \*\, ...\)

:py:obj:`asyncio_detailed <kittycad.api.unit.get_volume_unit_conversion.asyncio_detailed>`\ \(input\_unit\, output\_unit\, ...\)

:py:obj:`sync <kittycad.api.unit.get_volume_unit_conversion.sync>`\ \(input\_unit\, output\_unit\, value\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.unit.get_volume_unit_conversion.sync_detailed>`\ \(input\_unit\, output\_unit\, ...\)

_build_response() (in module kittycad.api.unit.get_volume_unit_conversion)

_get_kwargs() (in module kittycad.api.unit.get_volume_unit_conversion)

_parse_response() (in module kittycad.api.unit.get_volume_unit_conversion)

asyncio() (in module kittycad.api.unit.get_volume_unit_conversion)

Convert a volume unit value to another volume unit value. This is a nice endpoint to use for helper functions.

asyncio_detailed() (in module kittycad.api.unit.get_volume_unit_conversion)

sync_detailed() (in module kittycad.api.unit.get_volume_unit_conversion)

Contains methods for accessing the users API paths: A user is someone who uses the KittyCAD API. Here, we can create, delete, and list users. We can also get information about a user. Operations will only be authorized if the user is requesting information about themselves.

kittycad.api.users.delete_user_self

kittycad.api.users.get_session_for_user

kittycad.api.users.get_user

kittycad.api.users.get_user_extended

kittycad.api.users.get_user_front_hash_self

kittycad.api.users.get_user_onboarding_self

kittycad.api.users.get_user_self

kittycad.api.users.get_user_self_extended

kittycad.api.users.list_users

kittycad.api.users.list_users_extended

kittycad.api.users.update_user_self

:py:obj:`asyncio <kittycad.api.users.delete_user_self.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.delete_user_self.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.users.delete_user_self.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.delete_user_self.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.users.delete_user_self)

_parse_response() (in module kittycad.api.users.delete_user_self)

This endpoint requires authentication by any KittyCAD user. It deletes the authenticated user from KittyCAD's database.
This call will only succeed if all invoices associated with the user have been paid in full and there is no outstanding balance.

This endpoint requires authentication by any KittyCAD user. It deletes the authenticated user from KittyCAD’s database.

asyncio_detailed() (in module kittycad.api.users.delete_user_self)

rtype

Response[Union[Session, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.get_session_for_user.asyncio>`\ \(token\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.get_session_for_user.asyncio_detailed>`\ \(token\, \*\, client\)

:py:obj:`sync <kittycad.api.users.get_session_for_user.sync>`\ \(token\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_session_for_user.sync_detailed>`\ \(token\, \*\, client\)

_build_response() (in module kittycad.api.users.get_session_for_user)

_get_kwargs() (in module kittycad.api.users.get_session_for_user)

_parse_response() (in module kittycad.api.users.get_session_for_user)

asyncio_detailed() (in module kittycad.api.users.get_session_for_user)

sync_detailed() (in module kittycad.api.users.get_session_for_user)

To get information about yourself, use /users/me as the endpoint.

rtype

Response[Union[User, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.get_user.asyncio>`\ \(id\, \*\, client\)

To get information about yourself, use `/users/me` as the endpoint.

:py:obj:`asyncio_detailed <kittycad.api.users.get_user.asyncio_detailed>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.users.get_user.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user.sync_detailed>`\ \(id\, \*\, client\)

To get information about yourself, use `/users/me` as the endpoint. By doing so you will get the user information for the authenticated user.
Alternatively, to get information about the authenticated user, use `/user` endpoint.
To get information about any KittyCAD user, you must be a KittyCAD employee.

 as the endpoint. By doing so you will get the user information for the authenticated user.
Alternatively, to get information about the authenticated user, use 

 endpoint.

To get information about yourself, use /users-extended/me as the endpoint.

rtype

Response[Union[ExtendedUser, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.get_user_extended.asyncio>`\ \(id\, \*\, client\)

To get information about yourself, use `/users-extended/me` as the endpoint.

:py:obj:`asyncio_detailed <kittycad.api.users.get_user_extended.asyncio_detailed>`\ \(id\, \*\, client\)

:py:obj:`sync <kittycad.api.users.get_user_extended.sync>`\ \(id\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user_extended.sync_detailed>`\ \(id\, \*\, client\)

_build_response() (in module kittycad.api.users.get_user_extended)

_parse_response() (in module kittycad.api.users.get_user_extended)

To get information about yourself, use `/users-extended/me` as the endpoint. By doing so you will get the user information for the authenticated user.
Alternatively, to get information about the authenticated user, use `/user/extended` endpoint.

asyncio_detailed() (in module kittycad.api.users.get_user_extended)

sync_detailed() (in module kittycad.api.users.get_user_extended)

This info is sent to front when initialing the front chat, it prevents impersonations using js hacks in the browser

rtype

Response[Union[str, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.get_user_front_hash_self.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.get_user_front_hash_self.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.users.get_user_front_hash_self.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user_front_hash_self.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.users.get_user_front_hash_self)

_get_kwargs() (in module kittycad.api.users.get_user_front_hash_self)

_parse_response() (in module kittycad.api.users.get_user_front_hash_self)

asyncio() (in module kittycad.api.users.get_user_front_hash_self)

asyncio_detailed() (in module kittycad.api.users.get_user_front_hash_self)

sync_detailed() (in module kittycad.api.users.get_user_front_hash_self)

Checks key part of their api usage to determine their onboarding progress

rtype

Response[Union[Onboarding, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.get_user_onboarding_self.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.get_user_onboarding_self.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.users.get_user_onboarding_self.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user_onboarding_self.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.users.get_user_onboarding_self)

_get_kwargs() (in module kittycad.api.users.get_user_onboarding_self)

_parse_response() (in module kittycad.api.users.get_user_onboarding_self)

asyncio() (in module kittycad.api.users.get_user_onboarding_self)

asyncio_detailed() (in module kittycad.api.users.get_user_onboarding_self)

sync_detailed() (in module kittycad.api.users.get_user_onboarding_self)

Get the user information for the authenticated user.

rtype

rtype

:py:obj:`asyncio <kittycad.api.users.get_user_self.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.get_user_self.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.users.get_user_self.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user_self.sync_detailed>`\ \(\*\, client\)

Alternatively, you can also use the `/users/me` endpoint.

Alternatively, you can also use the 

rtype

rtype

:py:obj:`asyncio <kittycad.api.users.get_user_self_extended.asyncio>`\ \(\*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.get_user_self_extended.asyncio_detailed>`\ \(\*\, client\)

:py:obj:`sync <kittycad.api.users.get_user_self_extended.sync>`\ \(\*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.get_user_self_extended.sync_detailed>`\ \(\*\, client\)

_build_response() (in module kittycad.api.users.get_user_self_extended)

_get_kwargs() (in module kittycad.api.users.get_user_self_extended)

_parse_response() (in module kittycad.api.users.get_user_self_extended)

Alternatively, you can also use the `/users-extended/me` endpoint.

asyncio_detailed() (in module kittycad.api.users.get_user_self_extended)

sync_detailed() (in module kittycad.api.users.get_user_self_extended)

This endpoint required authentication by a KittyCAD employee.

rtype

Response[Union[UserResultsPage, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.list_users.asyncio>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`asyncio_detailed <kittycad.api.users.list_users.asyncio_detailed>`\ \(sort\_by\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.users.list_users.sync>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.users.list_users.sync_detailed>`\ \(sort\_by\, \*\, client\[\, limit\, ...\]\)

This endpoint required authentication by a KittyCAD employee. The users are returned in order of creation, with the most recently created users first.

rtype

Response[Union[ExtendedUserResultsPage, Error, None]]

rtype

:py:obj:`asyncio <kittycad.api.users.list_users_extended.asyncio>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`asyncio_detailed <kittycad.api.users.list_users_extended.asyncio_detailed>`\ \(sort\_by\, \*\, client\[\, ...\]\)

:py:obj:`sync <kittycad.api.users.list_users_extended.sync>`\ \(sort\_by\, \*\, client\[\, limit\, page\_token\]\)

:py:obj:`sync_detailed <kittycad.api.users.list_users_extended.sync_detailed>`\ \(sort\_by\, \*\, client\[\, limit\, ...\]\)

_build_response() (in module kittycad.api.users.list_users_extended)

_get_kwargs() (in module kittycad.api.users.list_users_extended)

_parse_response() (in module kittycad.api.users.list_users_extended)

asyncio_detailed() (in module kittycad.api.users.list_users_extended)

sync_detailed() (in module kittycad.api.users.list_users_extended)

rtype

rtype

:py:obj:`asyncio <kittycad.api.users.update_user_self.asyncio>`\ \(body\, \*\, client\)

:py:obj:`asyncio_detailed <kittycad.api.users.update_user_self.asyncio_detailed>`\ \(body\, \*\, client\)

:py:obj:`sync <kittycad.api.users.update_user_self.sync>`\ \(body\, \*\, client\)

:py:obj:`sync_detailed <kittycad.api.users.update_user_self.sync_detailed>`\ \(body\, \*\, client\)

_build_response() (in module kittycad.api.users.update_user_self)

_parse_response() (in module kittycad.api.users.update_user_self)

This endpoint requires authentication by any KittyCAD user. It updates information about the authenticated user.

asyncio_detailed() (in module kittycad.api.users.update_user_self)

Client([base_url, cookies, headers, ...])

A Client which has been authenticated for use on secured endpoints of the KittyCAD API.

ClientFromEnv([base_url, token, cookies, ...])

A Client which has been authenticated for use on secured endpoints that uses the KITTYCAD_API_TOKEN environment variable for the authentication token.

:py:obj:`Client <kittycad.client.Client>`\ \(\[base\_url\, cookies\, headers\, ...\]\)

:py:obj:`ClientFromEnv <kittycad.client.ClientFromEnv>`\ \(\[base\_url\, token\, cookies\, ...\]\)

Client(base_url='https://api.kittycad.io', *, token, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True)

base_url='https://api.kittycad.io', *, token, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True

{'base_url': <class 'str'>, 'cookies': typing.Dict[str, str], 'headers': typing.Dict[str, str], 'timeout': <class 'float'>, 'token': <class 'str'>, 'verify_ssl': typing.Union[str, bool, ssl.SSLContext]}

(Attribute(name='token', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=True, inherited=False, on_setattr=None, alias='token'), Attribute(name='base_url', default='https://api.kittycad.io', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='base_url'), Attribute(name='cookies', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='cookies'), Attribute(name='headers', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='headers'), Attribute(name='timeout', default=50.0, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'float'>, converter=None, kw_only=True, inherited=False, on_setattr=None, alias='timeout'), Attribute(name='verify_ssl', default=True, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[str, bool, ssl.SSLContext], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='verify_ssl'))

mappingproxy({'__module__': 'kittycad.client', '__annotations__': {'token': <class 'str'>, 'base_url': <class 'str'>, 'cookies': typing.Dict[str, str], 'headers': typing.Dict[str, str], 'timeout': <class 'float'>, 'verify_ssl': typing.Union[str, bool, ssl.SSLContext]}, '__doc__': 'A Client which has been authenticated for use on secured endpoints of the KittyCAD API.', 'get_headers': <function Client.get_headers>, 'with_headers': <function Client.with_headers>, 'get_cookies': <function Client.get_cookies>, 'with_cookies': <function Client.with_cookies>, 'get_timeout': <function Client.get_timeout>, 'with_timeout': <function Client.with_timeout>, '__dict__': <attribute '__dict__' of 'Client' objects>, '__weakref__': <attribute '__weakref__' of 'Client' objects>, '__attrs_attrs__': (Attribute(name='token', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=True, inherited=False, on_setattr=None, alias='token'), Attribute(name='base_url', default='https://api.kittycad.io', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='base_url'), Attribute(name='cookies', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='cookies'), Attribute(name='headers', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='headers'), Attribute(name='timeout', default=50.0, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'float'>, converter=None, kw_only=True, inherited=False, on_setattr=None, alias='timeout'), Attribute(name='verify_ssl', default=True, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[str, bool, ssl.SSLContext], converter=None, kw_only=True, inherited=False, on_setattr=None, alias='verify_ssl')), '__repr__': <function Client.__repr__>, '__eq__': <function Client.__eq__>, '__ne__': <function Client.__ne__>, '__lt__': <function Client.__lt__>, '__le__': <function Client.__le__>, '__gt__': <function Client.__gt__>, '__ge__': <function Client.__ge__>, '__hash__': None, '__init__': <function Client.__init__>, '__match_args__': ('base_url',)})

Client.__init__(base_url='https://api.kittycad.io', *, token, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True)

Get a new client matching this one with a new timeout (in seconds)

ClientFromEnv(base_url='https://api.kittycad.io', token=_Nothing.NOTHING, *, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True)

base_url='https://api.kittycad.io', token=_Nothing.NOTHING, *, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True

(Attribute(name='base_url', default='https://api.kittycad.io', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=True, on_setattr=None, alias='base_url'), Attribute(name='cookies', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='cookies'), Attribute(name='headers', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='headers'), Attribute(name='timeout', default=50.0, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'float'>, converter=None, kw_only=True, inherited=True, on_setattr=None, alias='timeout'), Attribute(name='verify_ssl', default=True, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[str, bool, ssl.SSLContext], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='verify_ssl'), Attribute(name='token', default=Factory(factory=<function ClientFromEnv.set_token>, takes_self=True), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token'))

mappingproxy({'__module__': 'kittycad.client', '__annotations__': {'token': <class 'str'>, 'base_url': 'str', 'cookies': 'Dict[str, str]', 'headers': 'Dict[str, str]', 'timeout': 'float', 'verify_ssl': 'Union[str, bool, ssl.SSLContext]'}, '__doc__': 'A Client which has been authenticated for use on secured endpoints that uses the KITTYCAD_API_TOKEN environment variable for the authentication token.', 'set_token': <function ClientFromEnv.set_token>, 'get_headers': <function ClientFromEnv.get_headers>, '__attrs_attrs__': (Attribute(name='base_url', default='https://api.kittycad.io', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=True, on_setattr=None, alias='base_url'), Attribute(name='cookies', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='cookies'), Attribute(name='headers', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Dict[str, str], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='headers'), Attribute(name='timeout', default=50.0, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'float'>, converter=None, kw_only=True, inherited=True, on_setattr=None, alias='timeout'), Attribute(name='verify_ssl', default=True, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[str, bool, ssl.SSLContext], converter=None, kw_only=True, inherited=True, on_setattr=None, alias='verify_ssl'), Attribute(name='token', default=Factory(factory=<function ClientFromEnv.set_token>, takes_self=True), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token')), '__repr__': <function ClientFromEnv.__repr__>, '__eq__': <function ClientFromEnv.__eq__>, '__ne__': <function ClientFromEnv.__ne__>, '__lt__': <function ClientFromEnv.__lt__>, '__le__': <function ClientFromEnv.__le__>, '__gt__': <function ClientFromEnv.__gt__>, '__ge__': <function ClientFromEnv.__ge__>, '__hash__': None, '__init__': <function ClientFromEnv.__init__>, '__match_args__': ('base_url', 'token')})

ClientFromEnv.__init__(base_url='https://api.kittycad.io', token=_Nothing.NOTHING, *, cookies=_Nothing.NOTHING, headers=_Nothing.NOTHING, timeout=50.0, verify_ssl=True)

__init__([base_url, cookies, headers, ...])

Method generated by attrs for class Client.

get_cookies()

rtype

Dict[str, str]

get_headers()

Get headers to be used in all endpoints

get_timeout()

rtype

float

with_cookies(cookies)

Get a new client matching this one with additional cookies

with_headers(headers)

Get a new client matching this one with additional headers

with_timeout(timeout)

:py:obj:`__init__ <kittycad.client.Client.__init__>`\ \(\[base\_url\, cookies\, headers\, ...\]\)

:py:obj:`get_cookies <kittycad.client.Client.get_cookies>`\ \(\)

:py:obj:`get_headers <kittycad.client.Client.get_headers>`\ \(\)

:py:obj:`get_timeout <kittycad.client.Client.get_timeout>`\ \(\)

:py:obj:`with_cookies <kittycad.client.Client.with_cookies>`\ \(cookies\)

:py:obj:`with_headers <kittycad.client.Client.with_headers>`\ \(headers\)

:py:obj:`with_timeout <kittycad.client.Client.with_timeout>`\ \(timeout\)

token

base_url

cookies

headers

timeout

verify_ssl

__init__([base_url, token, cookies, ...])

Method generated by attrs for class ClientFromEnv.

rtype

Get headers to be used in authenticated endpoints

rtype

float

set_token()

:py:obj:`__init__ <kittycad.client.ClientFromEnv.__init__>`\ \(\[base\_url\, token\, cookies\, ...\]\)

:py:obj:`get_cookies <kittycad.client.ClientFromEnv.get_cookies>`\ \(\)

:py:obj:`get_headers <kittycad.client.ClientFromEnv.get_headers>`\ \(\)

:py:obj:`get_timeout <kittycad.client.ClientFromEnv.get_timeout>`\ \(\)

:py:obj:`set_token <kittycad.client.ClientFromEnv.set_token>`\ \(\)

:py:obj:`with_cookies <kittycad.client.ClientFromEnv.with_cookies>`\ \(cookies\)

:py:obj:`with_headers <kittycad.client.ClientFromEnv.with_headers>`\ \(headers\)

:py:obj:`with_timeout <kittycad.client.ClientFromEnv.with_timeout>`\ \(timeout\)

{'base_url': 'str', 'cookies': 'Dict[str, str]', 'headers': 'Dict[str, str]', 'timeout': 'float', 'token': <class 'str'>, 'verify_ssl': 'Union[str, bool, ssl.SSLContext]'}

kittycad.models.account_provider

kittycad.models.ai_plugin_api

kittycad.models.ai_plugin_api_type

kittycad.models.ai_plugin_auth

kittycad.models.ai_plugin_auth_type

kittycad.models.ai_plugin_http_auth_type

kittycad.models.ai_plugin_manifest

kittycad.models.annotation_line_end

kittycad.models.annotation_line_end_options

kittycad.models.annotation_options

kittycad.models.annotation_text_alignment_x

kittycad.models.annotation_text_alignment_y

kittycad.models.annotation_text_options

kittycad.models.annotation_type

kittycad.models.api_call_query_group

kittycad.models.api_call_query_group_by

kittycad.models.api_call_status

kittycad.models.api_call_with_price

kittycad.models.api_call_with_price_results_page

kittycad.models.api_token

kittycad.models.api_token_results_page

kittycad.models.app_client_info

kittycad.models.async_api_call

kittycad.models.async_api_call_output

kittycad.models.async_api_call_results_page

kittycad.models.async_api_call_type

kittycad.models.axis

kittycad.models.axis_direction_pair

kittycad.models.billing_info

kittycad.models.cache_metadata

kittycad.models.camera_drag_interaction_type

kittycad.models.card_details

kittycad.models.cluster

kittycad.models.code_language

kittycad.models.code_output

kittycad.models.color

kittycad.models.commit

kittycad.models.connection

kittycad.models.country_code

kittycad.models.coupon

kittycad.models.created_at_sort_mode

kittycad.models.currency

kittycad.models.customer

kittycad.models.customer_balance

kittycad.models.device_access_token_request_form

kittycad.models.device_auth_request_form

kittycad.models.device_auth_verify_params

kittycad.models.direction

kittycad.models.discount

kittycad.models.docker_system_info

kittycad.models.email_authentication_form

kittycad.models.engine_metadata

kittycad.models.entity_type

kittycad.models.environment

kittycad.models.error

kittycad.models.executor_metadata

kittycad.models.export_file

kittycad.models.extended_user

kittycad.models.extended_user_results_page

kittycad.models.file_center_of_mass

kittycad.models.file_conversion

kittycad.models.file_density

kittycad.models.file_export_format

kittycad.models.file_import_format

kittycad.models.file_mass

kittycad.models.file_surface_area

kittycad.models.file_system_metadata

kittycad.models.file_volume

kittycad.models.gateway

kittycad.models.image_type

kittycad.models.index_info

kittycad.models.input_format

kittycad.models.invoice

kittycad.models.invoice_line_item

kittycad.models.invoice_status

kittycad.models.jetstream

kittycad.models.jetstream_api_stats

kittycad.models.jetstream_config

kittycad.models.jetstream_stats

kittycad.models.leaf_node

kittycad.models.mesh

kittycad.models.meta_cluster_info

kittycad.models.metadata

kittycad.models.method

kittycad.models.modeling_cmd

kittycad.models.modeling_cmd_id

kittycad.models.modeling_cmd_req

kittycad.models.modeling_cmd_req_batch

kittycad.models.modeling_error

kittycad.models.modeling_outcome

kittycad.models.modeling_outcomes

kittycad.models.new_address

kittycad.models.o_auth2_client_info

kittycad.models.o_auth2_grant_type

kittycad.models.ok_modeling_cmd_response

kittycad.models.onboarding

kittycad.models.output_file

kittycad.models.output_format

kittycad.models.path_segment

kittycad.models.payment_intent

kittycad.models.payment_method

kittycad.models.payment_method_card_checks

kittycad.models.payment_method_type

kittycad.models.plugins_info

kittycad.models.point2d

kittycad.models.point3d

kittycad.models.point_e_metadata

kittycad.models.pong

kittycad.models.registry_service_config

kittycad.models.runtime

kittycad.models.scene_selection_type

kittycad.models.session

kittycad.models.storage

kittycad.models.system

kittycad.models.system_info_cgroup_driver_enum

kittycad.models.system_info_cgroup_version_enum

kittycad.models.system_info_default_address_pools

kittycad.models.system_info_isolation_enum

kittycad.models.unit_angle

kittycad.models.unit_angle_conversion

kittycad.models.unit_area

kittycad.models.unit_area_conversion

kittycad.models.unit_current

kittycad.models.unit_current_conversion

kittycad.models.unit_density

kittycad.models.unit_energy

kittycad.models.unit_energy_conversion

kittycad.models.unit_force

kittycad.models.unit_force_conversion

kittycad.models.unit_frequency

kittycad.models.unit_frequency_conversion

kittycad.models.unit_length

kittycad.models.unit_length_conversion

kittycad.models.unit_mass

kittycad.models.unit_mass_conversion

kittycad.models.unit_power

kittycad.models.unit_power_conversion

kittycad.models.unit_pressure

kittycad.models.unit_pressure_conversion

kittycad.models.unit_temperature

kittycad.models.unit_temperature_conversion

kittycad.models.unit_torque

kittycad.models.unit_torque_conversion

kittycad.models.unit_volume

kittycad.models.unit_volume_conversion

kittycad.models.update_user

kittycad.models.user

kittycad.models.user_results_page

kittycad.models.uuid

kittycad.models.verification_token

AccountProvider(value[, names, module, ...])

An account provider.

:py:obj:`AccountProvider <kittycad.models.account_provider.AccountProvider>`\ \(value\[\, names\, module\, ...\]\)

AccountProvider(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None

GITHUB (kittycad.models.account_provider.AccountProvider attribute)

GOOGLE (kittycad.models.account_provider.AccountProvider attribute)

docstring of kittycad.models.account_provider.AccountProvider.GOOGLE

__add__() (kittycad.models.account_provider.AccountProvider method)

__annotations__ (kittycad.models.account_provider.AccountProvider attribute)

__contains__() (kittycad.models.account_provider.AccountProvider method)

__dict__ (kittycad.models.account_provider.AccountProvider attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.account_provider', '__doc__': 'An account provider.', '__str__': <function AccountProvider.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['GOOGLE', 'GITHUB'], '_member_map_': {'GOOGLE': <AccountProvider.GOOGLE: 'google'>, 'GITHUB': <AccountProvider.GITHUB: 'github'>}, '_value2member_map_': {'google': <AccountProvider.GOOGLE: 'google'>, 'github': <AccountProvider.GITHUB: 'github'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AccountProvider' objects>, '__weakref__': <attribute '__weakref__' of 'AccountProvider' objects>, 'GOOGLE': <AccountProvider.GOOGLE: 'google'>, 'GITHUB': <AccountProvider.GITHUB: 'github'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.account_provider.AccountProvider method)

__eq__() (kittycad.models.account_provider.AccountProvider method)

__format__() (kittycad.models.account_provider.AccountProvider method)

Return a formatted version of the string as described by format_spec.

__ge__() (kittycad.models.account_provider.AccountProvider method)

__getattribute__() (kittycad.models.account_provider.AccountProvider method)

__getitem__() (kittycad.models.account_provider.AccountProvider method)

__getnewargs__() (kittycad.models.account_provider.AccountProvider method)

__gt__() (kittycad.models.account_provider.AccountProvider method)

__hash__() (kittycad.models.account_provider.AccountProvider method)

__init__() (kittycad.models.account_provider.AccountProvider method)

__iter__() (kittycad.models.account_provider.AccountProvider method)

__le__() (kittycad.models.account_provider.AccountProvider method)

__len__() (kittycad.models.account_provider.AccountProvider method)

__lt__() (kittycad.models.account_provider.AccountProvider method)

__mod__() (kittycad.models.account_provider.AccountProvider method)

__module__ (kittycad.models.account_provider.AccountProvider attribute)

__mul__() (kittycad.models.account_provider.AccountProvider method)

__ne__() (kittycad.models.account_provider.AccountProvider method)

__new__() (kittycad.models.account_provider.AccountProvider method)

__reduce_ex__() (kittycad.models.account_provider.AccountProvider method)

__repr__() (kittycad.models.account_provider.AccountProvider method)

__rmod__() (kittycad.models.account_provider.AccountProvider method)

__rmul__() (kittycad.models.account_provider.AccountProvider method)

__sizeof__() (kittycad.models.account_provider.AccountProvider method)

__str__() (kittycad.models.account_provider.AccountProvider method)

AccountProvider._generate_next_value_(start, count, last_values)

name: the name of the member
start: the initial start value or None
count: the number of existing members
last_values: the list of values assigned

_member_map_ (kittycad.models.account_provider.AccountProvider attribute)

{'GITHUB': AccountProvider.GITHUB, 'GOOGLE': AccountProvider.GOOGLE}

_member_names_ (kittycad.models.account_provider.AccountProvider attribute)

_member_type_ (kittycad.models.account_provider.AccountProvider attribute)

_new_member_() (kittycad.models.account_provider.AccountProvider method)

Create and return a new object.  See help(type) for accurate signature.

_unhashable_values_ (kittycad.models.account_provider.AccountProvider attribute)

_use_args_ (kittycad.models.account_provider.AccountProvider attribute)

_value2member_map_ (kittycad.models.account_provider.AccountProvider attribute)

{'github': AccountProvider.GITHUB, 'google': AccountProvider.GOOGLE}

_value_repr_() (kittycad.models.account_provider.AccountProvider method)

capitalize() (kittycad.models.account_provider.AccountProvider method)

More specifically, make the first character have upper case and the rest lower
case.

casefold() (kittycad.models.account_provider.AccountProvider method)

Return a version of the string suitable for caseless comparisons.

center() (kittycad.models.account_provider.AccountProvider method)

Padding is done using the specified fill character (default is a space).

count() (kittycad.models.account_provider.AccountProvider method)

Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are
interpreted as in slice notation.

encode() (kittycad.models.account_provider.AccountProvider method)

errors
The error handling scheme to use for encoding errors.
The default is 'strict' meaning that encoding errors raise a
UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.

The default is ‘strict’ meaning that encoding errors raise a
UnicodeEncodeError.  Other possible values are ‘ignore’, ‘replace’ and
‘xmlcharrefreplace’ as well as any other name registered with

endswith() (kittycad.models.account_provider.AccountProvider method)

Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.

expandtabs() (kittycad.models.account_provider.AccountProvider method)

Return a copy where all tab characters are expanded using spaces.

find() (kittycad.models.account_provider.AccountProvider method)

Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.

format() (kittycad.models.account_provider.AccountProvider method)

Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').

The substitutions are identified by braces (‘{’ and ‘}’).

format_map() (kittycad.models.account_provider.AccountProvider method)

Return a formatted version of S, using substitutions from mapping.

index() (kittycad.models.account_provider.AccountProvider method)

isalnum() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is an alpha-numeric string, False otherwise.

A string is alpha-numeric if all characters in the string are alpha-numeric and
there is at least one character in the string.

isalpha() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is an alphabetic string, False otherwise.

A string is alphabetic if all characters in the string are alphabetic and there
is at least one character in the string.

isascii() (kittycad.models.account_provider.AccountProvider method)

Return True if all characters in the string are ASCII, False otherwise.

ASCII characters have code points in the range U+0000-U+007F.
Empty string is ASCII too.

isdecimal() (kittycad.models.account_provider.AccountProvider method)

A string is a decimal string if all characters in the string are decimal and

isdigit() (kittycad.models.account_provider.AccountProvider method)

A string is a digit string if all characters in the string are digits and there

isidentifier() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is a valid Python identifier, False otherwise.

Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
such as "def" or "class".

such as “def” or “class”.

islower() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is a lowercase string, False otherwise.

A string is lowercase if all cased characters in the string are lowercase and
there is at least one cased character in the string.

isnumeric() (kittycad.models.account_provider.AccountProvider method)

A string is numeric if all characters in the string are numeric and there is at
least one character in the string.

isprintable() (kittycad.models.account_provider.AccountProvider method)

A string is printable if all of its characters are considered printable in
repr() or if it is empty.

isspace() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is a whitespace string, False otherwise.

A string is whitespace if all characters in the string are whitespace and there

istitle() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is a title-cased string, False otherwise.

In a title-cased string, upper- and title-case characters may only
follow uncased characters and lowercase characters only cased ones.

isupper() (kittycad.models.account_provider.AccountProvider method)

Return True if the string is an uppercase string, False otherwise.

A string is uppercase if all cased characters in the string are uppercase and

join() (kittycad.models.account_provider.AccountProvider method)

The string whose method is called is inserted in between each given string.
The result is returned as a new string.

ljust() (kittycad.models.account_provider.AccountProvider method)

lower() (kittycad.models.account_provider.AccountProvider method)

lstrip() (kittycad.models.account_provider.AccountProvider method)

If chars is given and not None, remove characters in chars instead.

maketrans() (kittycad.models.account_provider.AccountProvider static method)

If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.

partition() (kittycad.models.account_provider.AccountProvider method)

Partition the string into three parts using the given separator.

This will search for the separator in the string.  If the separator is found,
returns a 3-tuple containing the part before the separator, the separator
itself, and the part after it.

If the separator is not found, returns a 3-tuple containing the original string
and two empty strings.

removeprefix() (kittycad.models.account_provider.AccountProvider method)

If the string starts with the prefix string, return string[len(prefix):].
Otherwise, return a copy of the original string.

removesuffix() (kittycad.models.account_provider.AccountProvider method)

If the string ends with the suffix string and that suffix is not empty,
return string[:-len(suffix)]. Otherwise, return a copy of the original
string.

replace() (kittycad.models.account_provider.AccountProvider method)

Return a copy with all occurrences of substring old replaced by new.

count
  Maximum number of occurrences to replace.
  -1 (the default value) means replace all occurrences.

count
Maximum number of occurrences to replace.
-1 (the default value) means replace all occurrences.

If the optional argument count is given, only the first count occurrences are
replaced.

rfind() (kittycad.models.account_provider.AccountProvider method)

Return the highest index in S where substring sub is found,

rindex() (kittycad.models.account_provider.AccountProvider method)

rjust() (kittycad.models.account_provider.AccountProvider method)

rpartition() (kittycad.models.account_provider.AccountProvider method)

This will search for the separator in the string, starting at the end. If
the separator is found, returns a 3-tuple containing the part before the
separator, the separator itself, and the part after it.

If the separator is not found, returns a 3-tuple containing two empty strings
and the original string.

rsplit() (kittycad.models.account_provider.AccountProvider method)

Return a list of the substrings in the string, using sep as the separator string.

sep
  The separator used to split the string.

  When set to None (the default value), will split on any whitespace
  character (including \\n \\r \\t \\f and spaces) and will discard
  empty strings from the result.
maxsplit
  Maximum number of splits (starting from the left).
  -1 (the default value) means no limit.

sep
The separator used to split the string.

When set to None (the default value), will split on any whitespace
character (including \\n \\r \\t \\f and spaces) and will discard
empty strings from the result.

maxsplit
Maximum number of splits (starting from the left).
-1 (the default value) means no limit.

Splitting starts at the end of the string and works to the front.

rstrip() (kittycad.models.account_provider.AccountProvider method)

split() (kittycad.models.account_provider.AccountProvider method)

Note, str.split() is mainly useful for data that has been intentionally
delimited.  With natural text that includes punctuation, consider using
the regular expression module.

splitlines() (kittycad.models.account_provider.AccountProvider method)

Return a list of the lines in the string, breaking at line boundaries.

Line breaks are not included in the resulting list unless keepends is given and
true.

startswith() (kittycad.models.account_provider.AccountProvider method)

Return True if S starts with the specified prefix, False otherwise.
prefix can also be a tuple of strings to try.

strip() (kittycad.models.account_provider.AccountProvider method)

Return a copy of the string with leading and trailing whitespace removed.

swapcase() (kittycad.models.account_provider.AccountProvider method)

Convert uppercase characters to lowercase and lowercase characters to uppercase.

title() (kittycad.models.account_provider.AccountProvider method)

More specifically, words start with uppercased characters and all remaining
cased characters have lower case.

translate() (kittycad.models.account_provider.AccountProvider method)

Replace each character in the string using the given translation table.

table
  Translation table, which must be a mapping of Unicode ordinals to
  Unicode ordinals, strings, or None.

table
Translation table, which must be a mapping of Unicode ordinals to
Unicode ordinals, strings, or None.

The table must implement lookup/indexing via __getitem__, for instance a
dictionary or list.  If this operation raises LookupError, the character is
left untouched.  Characters mapped to None are deleted.

upper() (kittycad.models.account_provider.AccountProvider method)

zfill() (kittycad.models.account_provider.AccountProvider method)

Pad a numeric string with zeros on the left, to fill a field of the given width.

__init__(*args, **kwds)

capitalize()

Return a capitalized version of the string.

casefold()

center(width[, fillchar])

Return a centered string of length width.

count(sub[, start[, end]])

Return the number of non-overlapping occurrences of substring sub in string S[start:end].

encode([encoding, errors])

Encode the string using the codec registered for encoding.

endswith(suffix[, start[, end]])

expandtabs([tabsize])

find(sub[, start[, end]])

Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end].

format(*args, **kwargs)

format_map(mapping)

index(sub[, start[, end]])

isalnum()

isalpha()

isascii()

isdecimal()

Return True if the string is a decimal string, False otherwise.

isdigit()

Return True if the string is a digit string, False otherwise.

isidentifier()

islower()

isnumeric()

Return True if the string is a numeric string, False otherwise.

isprintable()

Return True if the string is printable, False otherwise.

isspace()

istitle()

isupper()

join(iterable, /)

Concatenate any number of strings.

ljust(width[, fillchar])

Return a left-justified string of length width.

lower()

Return a copy of the string converted to lowercase.

lstrip([chars])

Return a copy of the string with leading whitespace removed.

maketrans

Return a translation table usable for str.translate().

partition(sep, /)

removeprefix(prefix, /)

Return a str with the given prefix string removed if present.

removesuffix(suffix, /)

Return a str with the given suffix string removed if present.

replace(old, new[, count])

rfind(sub[, start[, end]])

Return the highest index in S where substring sub is found, such that sub is contained within S[start:end].

rindex(sub[, start[, end]])

rjust(width[, fillchar])

Return a right-justified string of length width.

rpartition(sep, /)

rsplit([sep, maxsplit])

rstrip([chars])

Return a copy of the string with trailing whitespace removed.

split([sep, maxsplit])

splitlines([keepends])

startswith(prefix[, start[, end]])

strip([chars])

swapcase()

title()

Return a version of the string where each word is titlecased.

translate(table, /)

upper()

Return a copy of the string converted to uppercase.

zfill(width, /)

:py:obj:`__init__ <kittycad.models.account_provider.AccountProvider.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.account_provider.AccountProvider.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.account_provider.AccountProvider.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.account_provider.AccountProvider.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.account_provider.AccountProvider.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.account_provider.AccountProvider.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.account_provider.AccountProvider.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.account_provider.AccountProvider.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.account_provider.AccountProvider.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.account_provider.AccountProvider.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.account_provider.AccountProvider.lower>`\ \(\)

:py:obj:`partition <kittycad.models.account_provider.AccountProvider.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.account_provider.AccountProvider.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.account_provider.AccountProvider.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.account_provider.AccountProvider.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.account_provider.AccountProvider.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.account_provider.AccountProvider.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.account_provider.AccountProvider.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.account_provider.AccountProvider.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.account_provider.AccountProvider.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.account_provider.AccountProvider.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.account_provider.AccountProvider.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.account_provider.AccountProvider.title>`\ \(\)

:py:obj:`translate <kittycad.models.account_provider.AccountProvider.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.account_provider.AccountProvider.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.account_provider.AccountProvider.zfill>`\ \(width\, \/\)

AiPluginApi([is_user_authenticated, type, url])

AI plugin api information.

:py:obj:`AiPluginApi <kittycad.models.ai_plugin_api.AiPluginApi>`\ \(\[is\_user\_authenticated\, type\, url\]\)

AiPluginApi(is_user_authenticated=False, type=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

(is_user_authenticated=False, type=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.ai_plugin_api.AiPluginApi attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'is_user_authenticated': typing.Union[kittycad.types.Unset, bool], 'type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api_type.AiPluginApiType], 'url': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.ai_plugin_api.AiPluginApi attribute)

(Attribute(name='is_user_authenticated', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='is_user_authenticated'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api_type.AiPluginApiType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ai_plugin_api.AiPluginApi method)

__delitem__() (kittycad.models.ai_plugin_api.AiPluginApi method)

mappingproxy({'__module__': 'kittycad.models.ai_plugin_api', '__annotations__': {'is_user_authenticated': typing.Union[kittycad.types.Unset, bool], 'type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api_type.AiPluginApiType], 'url': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'AI plugin api information.', 'to_dict': <function AiPluginApi.to_dict>, 'from_dict': <classmethod(<function AiPluginApi.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AiPluginApi.__getitem__>, '__setitem__': <function AiPluginApi.__setitem__>, '__delitem__': <function AiPluginApi.__delitem__>, '__contains__': <function AiPluginApi.__contains__>, '__dict__': <attribute '__dict__' of 'AiPluginApi' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginApi' objects>, '__attrs_attrs__': (Attribute(name='is_user_authenticated', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='is_user_authenticated'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api_type.AiPluginApiType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AiPluginApi.__repr__>, '__eq__': <function AiPluginApi.__eq__>, '__ne__': <function AiPluginApi.__ne__>, '__lt__': <function AiPluginApi.__lt__>, '__le__': <function AiPluginApi.__le__>, '__gt__': <function AiPluginApi.__gt__>, '__ge__': <function AiPluginApi.__ge__>, '__hash__': None, '__init__': <function AiPluginApi.__init__>, '__match_args__': ('is_user_authenticated', 'type', 'url')})

__getitem__() (kittycad.models.ai_plugin_api.AiPluginApi method)

AiPluginApi.__init__(is_user_authenticated=False, type=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.ai_plugin_api.AiPluginApi attribute)

__module__ (kittycad.models.ai_plugin_api.AiPluginApi attribute)

__setitem__() (kittycad.models.ai_plugin_api.AiPluginApi method)

additional_keys (kittycad.models.ai_plugin_api.AiPluginApi property)

additional_properties (kittycad.models.ai_plugin_api.AiPluginApi attribute)

from_dict() (kittycad.models.ai_plugin_api.AiPluginApi class method)

is_user_authenticated (kittycad.models.ai_plugin_api.AiPluginApi attribute)

__init__([is_user_authenticated, type, url])

Method generated by attrs for class AiPluginApi.

from_dict(src_dict)

rtype

TypeVar(SB, bound= AiPluginApi)

to_dict()

rtype

Dict[str, Any]

:py:obj:`__init__ <kittycad.models.ai_plugin_api.AiPluginApi.__init__>`\ \(\[is\_user\_authenticated\, type\, url\]\)

:py:obj:`to_dict <kittycad.models.ai_plugin_api.AiPluginApi.to_dict>`\ \(\)

additional_keys

is_user_authenticated

type

url

additional_properties

AiPluginApiType(value[, names, module, ...])

AI plugin api type.

:py:obj:`AiPluginApiType <kittycad.models.ai_plugin_api_type.AiPluginApiType>`\ \(value\[\, names\, module\, ...\]\)

AiPluginApiType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

OPENAPI (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

__add__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__annotations__ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

__contains__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__dict__ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.ai_plugin_api_type', '__doc__': 'AI plugin api type.', '__str__': <function AiPluginApiType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['OPENAPI'], '_member_map_': {'OPENAPI': <AiPluginApiType.OPENAPI: 'openapi'>}, '_value2member_map_': {'openapi': <AiPluginApiType.OPENAPI: 'openapi'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AiPluginApiType' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginApiType' objects>, 'OPENAPI': <AiPluginApiType.OPENAPI: 'openapi'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__eq__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__format__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__ge__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__getattribute__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__getitem__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__getnewargs__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__gt__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__hash__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__init__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__iter__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__le__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__len__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__lt__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__mod__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__module__ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

__mul__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__ne__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__new__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__reduce_ex__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__repr__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__rmod__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__rmul__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__sizeof__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

__str__() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

AiPluginApiType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

_member_names_ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

_member_type_ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

_new_member_() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

_use_args_ (kittycad.models.ai_plugin_api_type.AiPluginApiType attribute)

_value_repr_() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

capitalize() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

casefold() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

center() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

count() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

encode() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

endswith() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

expandtabs() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

find() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

format() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

format_map() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

index() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isalnum() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isalpha() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isascii() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isdecimal() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isdigit() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isidentifier() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

islower() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isnumeric() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isprintable() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isspace() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

istitle() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

isupper() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

join() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

ljust() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

lower() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

lstrip() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

maketrans() (kittycad.models.ai_plugin_api_type.AiPluginApiType static method)

partition() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

removeprefix() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

removesuffix() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

replace() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rfind() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rindex() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rjust() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rpartition() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rsplit() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

rstrip() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

split() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

splitlines() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

startswith() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

strip() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

swapcase() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

title() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

translate() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

upper() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

zfill() (kittycad.models.ai_plugin_api_type.AiPluginApiType method)

:py:obj:`__init__ <kittycad.models.ai_plugin_api_type.AiPluginApiType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.ai_plugin_api_type.AiPluginApiType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.ai_plugin_api_type.AiPluginApiType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.ai_plugin_api_type.AiPluginApiType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.ai_plugin_api_type.AiPluginApiType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.ai_plugin_api_type.AiPluginApiType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.ai_plugin_api_type.AiPluginApiType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.ai_plugin_api_type.AiPluginApiType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.ai_plugin_api_type.AiPluginApiType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.ai_plugin_api_type.AiPluginApiType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.ai_plugin_api_type.AiPluginApiType.lower>`\ \(\)

:py:obj:`partition <kittycad.models.ai_plugin_api_type.AiPluginApiType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.ai_plugin_api_type.AiPluginApiType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.ai_plugin_api_type.AiPluginApiType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.ai_plugin_api_type.AiPluginApiType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.ai_plugin_api_type.AiPluginApiType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.ai_plugin_api_type.AiPluginApiType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.ai_plugin_api_type.AiPluginApiType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.ai_plugin_api_type.AiPluginApiType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.ai_plugin_api_type.AiPluginApiType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.ai_plugin_api_type.AiPluginApiType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.ai_plugin_api_type.AiPluginApiType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.ai_plugin_api_type.AiPluginApiType.title>`\ \(\)

:py:obj:`translate <kittycad.models.ai_plugin_api_type.AiPluginApiType.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.ai_plugin_api_type.AiPluginApiType.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.ai_plugin_api_type.AiPluginApiType.zfill>`\ \(width\, \/\)

AiPluginAuth([authorization_type, type])

AI plugin auth information.

:py:obj:`AiPluginAuth <kittycad.models.ai_plugin_auth.AiPluginAuth>`\ \(\[authorization\_type\, type\]\)

AiPluginAuth(authorization_type=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

(authorization_type=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'authorization_type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType], 'type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth_type.AiPluginAuthType]}

__attrs_attrs__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

(Attribute(name='authorization_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='authorization_type'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth_type.AiPluginAuthType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ai_plugin_auth.AiPluginAuth method)

__delitem__() (kittycad.models.ai_plugin_auth.AiPluginAuth method)

__dict__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

mappingproxy({'__module__': 'kittycad.models.ai_plugin_auth', '__annotations__': {'authorization_type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType], 'type': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth_type.AiPluginAuthType], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'AI plugin auth information.', 'to_dict': <function AiPluginAuth.to_dict>, 'from_dict': <classmethod(<function AiPluginAuth.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AiPluginAuth.__getitem__>, '__setitem__': <function AiPluginAuth.__setitem__>, '__delitem__': <function AiPluginAuth.__delitem__>, '__contains__': <function AiPluginAuth.__contains__>, '__dict__': <attribute '__dict__' of 'AiPluginAuth' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginAuth' objects>, '__attrs_attrs__': (Attribute(name='authorization_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='authorization_type'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth_type.AiPluginAuthType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AiPluginAuth.__repr__>, '__eq__': <function AiPluginAuth.__eq__>, '__ne__': <function AiPluginAuth.__ne__>, '__lt__': <function AiPluginAuth.__lt__>, '__le__': <function AiPluginAuth.__le__>, '__gt__': <function AiPluginAuth.__gt__>, '__ge__': <function AiPluginAuth.__ge__>, '__hash__': None, '__init__': <function AiPluginAuth.__init__>, '__match_args__': ('authorization_type', 'type')})

__getitem__() (kittycad.models.ai_plugin_auth.AiPluginAuth method)

__hash__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

AiPluginAuth.__init__(authorization_type=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

__module__ (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

__setitem__() (kittycad.models.ai_plugin_auth.AiPluginAuth method)

additional_keys (kittycad.models.ai_plugin_auth.AiPluginAuth property)

additional_properties (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

authorization_type (kittycad.models.ai_plugin_auth.AiPluginAuth attribute)

from_dict() (kittycad.models.ai_plugin_auth.AiPluginAuth class method)

__init__([authorization_type, type])

Method generated by attrs for class AiPluginAuth.

rtype

TypeVar(NP, bound= AiPluginAuth)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ai_plugin_auth.AiPluginAuth.__init__>`\ \(\[authorization\_type\, type\]\)

:py:obj:`to_dict <kittycad.models.ai_plugin_auth.AiPluginAuth.to_dict>`\ \(\)

authorization_type

type

AiPluginAuthType(value[, names, module, ...])

AI plugin auth type.

:py:obj:`AiPluginAuthType <kittycad.models.ai_plugin_auth_type.AiPluginAuthType>`\ \(value\[\, names\, module\, ...\]\)

AiPluginAuthType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

NONE (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

docstring of kittycad.models.ai_plugin_auth_type.AiPluginAuthType.NONE

OAUTH (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

SERVICE_HTTP (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

docstring of kittycad.models.ai_plugin_auth_type.AiPluginAuthType.SERVICE_HTTP

USER_HTTP (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

docstring of kittycad.models.ai_plugin_auth_type.AiPluginAuthType.USER_HTTP

__add__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__annotations__ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

__contains__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__dict__ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.ai_plugin_auth_type', '__doc__': 'AI plugin auth type.', '__str__': <function AiPluginAuthType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['NONE', 'USER_HTTP', 'SERVICE_HTTP', 'OAUTH'], '_member_map_': {'NONE': <AiPluginAuthType.NONE: 'none'>, 'USER_HTTP': <AiPluginAuthType.USER_HTTP: 'user_http'>, 'SERVICE_HTTP': <AiPluginAuthType.SERVICE_HTTP: 'service_http'>, 'OAUTH': <AiPluginAuthType.OAUTH: 'oauth'>}, '_value2member_map_': {'none': <AiPluginAuthType.NONE: 'none'>, 'user_http': <AiPluginAuthType.USER_HTTP: 'user_http'>, 'service_http': <AiPluginAuthType.SERVICE_HTTP: 'service_http'>, 'oauth': <AiPluginAuthType.OAUTH: 'oauth'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AiPluginAuthType' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginAuthType' objects>, 'NONE': <AiPluginAuthType.NONE: 'none'>, 'USER_HTTP': <AiPluginAuthType.USER_HTTP: 'user_http'>, 'SERVICE_HTTP': <AiPluginAuthType.SERVICE_HTTP: 'service_http'>, 'OAUTH': <AiPluginAuthType.OAUTH: 'oauth'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__eq__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__format__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__ge__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__getattribute__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__getitem__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__getnewargs__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__gt__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__hash__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__init__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__iter__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__le__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__len__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__lt__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__mod__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__module__ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

__mul__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__ne__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__new__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__reduce_ex__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__repr__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__rmod__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__rmul__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__sizeof__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

__str__() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

AiPluginAuthType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

{'NONE': AiPluginAuthType.NONE, 'OAUTH': AiPluginAuthType.OAUTH, 'SERVICE_HTTP': AiPluginAuthType.SERVICE_HTTP, 'USER_HTTP': AiPluginAuthType.USER_HTTP}

_member_names_ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

_member_type_ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

_new_member_() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

_use_args_ (kittycad.models.ai_plugin_auth_type.AiPluginAuthType attribute)

{'none': AiPluginAuthType.NONE, 'oauth': AiPluginAuthType.OAUTH, 'service_http': AiPluginAuthType.SERVICE_HTTP, 'user_http': AiPluginAuthType.USER_HTTP}

_value_repr_() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

capitalize() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

casefold() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

center() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

count() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

encode() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

endswith() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

expandtabs() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

find() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

format() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

format_map() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

index() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isalnum() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isalpha() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isascii() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isdecimal() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isdigit() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isidentifier() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

islower() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isnumeric() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isprintable() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isspace() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

istitle() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

isupper() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

join() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

ljust() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

lower() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

lstrip() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

maketrans() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType static method)

partition() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

removeprefix() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

removesuffix() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

replace() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rfind() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rindex() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rjust() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rpartition() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rsplit() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

rstrip() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

split() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

splitlines() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

startswith() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

strip() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

swapcase() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

title() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

translate() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

upper() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

zfill() (kittycad.models.ai_plugin_auth_type.AiPluginAuthType method)

:py:obj:`__init__ <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.ai_plugin_auth_type.AiPluginAuthType.zfill>`\ \(width\, \/\)

NONE

# User http.

USER_HTTP

# Service http.

SERVICE_HTTP

# OAuth.

OAUTH

AiPluginHttpAuthType(value[, names, module, ...])

AI plugin http auth type.

:py:obj:`AiPluginHttpAuthType <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType>`\ \(value\[\, names\, module\, ...\]\)

AiPluginHttpAuthType (class in kittycad.models.ai_plugin_http_auth_type)

AiPluginHttpAuthType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

BASIC (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType attribute)

docstring of kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.BASIC

BEARER (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType attribute)

__add__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.ai_plugin_http_auth_type', '__doc__': 'AI plugin http auth type.', '__str__': <function AiPluginHttpAuthType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['BASIC', 'BEARER'], '_member_map_': {'BASIC': <AiPluginHttpAuthType.BASIC: 'basic'>, 'BEARER': <AiPluginHttpAuthType.BEARER: 'bearer'>}, '_value2member_map_': {'basic': <AiPluginHttpAuthType.BASIC: 'basic'>, 'bearer': <AiPluginHttpAuthType.BEARER: 'bearer'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AiPluginHttpAuthType' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginHttpAuthType' objects>, 'BASIC': <AiPluginHttpAuthType.BASIC: 'basic'>, 'BEARER': <AiPluginHttpAuthType.BEARER: 'bearer'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__eq__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__ge__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__gt__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__le__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__len__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__lt__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__mod__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__mul__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__ne__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__new__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

__str__() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

AiPluginHttpAuthType._generate_next_value_(start, count, last_values)

{'BASIC': AiPluginHttpAuthType.BASIC, 'BEARER': AiPluginHttpAuthType.BEARER}

{'basic': AiPluginHttpAuthType.BASIC, 'bearer': AiPluginHttpAuthType.BEARER}

center() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

count() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

encode() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

find() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

format() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

index() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isalnum() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isalpha() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isascii() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isdigit() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

islower() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isspace() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

istitle() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

isupper() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

join() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

ljust() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

lower() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

lstrip() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

maketrans() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType static method)

replace() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

rfind() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

rindex() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

rjust() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

rsplit() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

rstrip() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

split() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

strip() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

title() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

upper() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

zfill() (kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType method)

:py:obj:`__init__ <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.ai_plugin_http_auth_type.AiPluginHttpAuthType.zfill>`\ \(width\, \/\)

AiPluginManifest([api, auth, contact_email, ...])

AI plugin manifest.

:py:obj:`AiPluginManifest <kittycad.models.ai_plugin_manifest.AiPluginManifest>`\ \(\[api\, auth\, contact\_email\, ...\]\)

AiPluginManifest(api=<kittycad.types.Unset object>, auth=<kittycad.types.Unset object>, contact_email=<kittycad.types.Unset object>, description_for_human=<kittycad.types.Unset object>, description_for_model=<kittycad.types.Unset object>, legal_info_url=<kittycad.types.Unset object>, logo_url=<kittycad.types.Unset object>, name_for_human=<kittycad.types.Unset object>, name_for_model=<kittycad.types.Unset object>, schema_version=<kittycad.types.Unset object>)

(api=<kittycad.types.Unset object>, auth=<kittycad.types.Unset object>, contact_email=<kittycad.types.Unset object>, description_for_human=<kittycad.types.Unset object>, description_for_model=<kittycad.types.Unset object>, legal_info_url=<kittycad.types.Unset object>, logo_url=<kittycad.types.Unset object>, name_for_human=<kittycad.types.Unset object>, name_for_model=<kittycad.types.Unset object>, schema_version=<kittycad.types.Unset object>)

This is used for OpenAI's ChatGPT plugins. You can read more about them [here](https://platform.openai.com/docs/plugins/getting-started/plugin-manifest).

This is used for OpenAI’s ChatGPT plugins. You can read more about them [here](

__annotations__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'api': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api.AiPluginApi], 'auth': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth.AiPluginAuth], 'contact_email': typing.Union[kittycad.types.Unset, str], 'description_for_human': typing.Union[kittycad.types.Unset, str], 'description_for_model': typing.Union[kittycad.types.Unset, str], 'legal_info_url': typing.Union[kittycad.types.Unset, str], 'logo_url': typing.Union[kittycad.types.Unset, str], 'name_for_human': typing.Union[kittycad.types.Unset, str], 'name_for_model': typing.Union[kittycad.types.Unset, str], 'schema_version': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

(Attribute(name='api', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api.AiPluginApi], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='api'), Attribute(name='auth', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth.AiPluginAuth], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth'), Attribute(name='contact_email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='contact_email'), Attribute(name='description_for_human', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description_for_human'), Attribute(name='description_for_model', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description_for_model'), Attribute(name='legal_info_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='legal_info_url'), Attribute(name='logo_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='logo_url'), Attribute(name='name_for_human', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name_for_human'), Attribute(name='name_for_model', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name_for_model'), Attribute(name='schema_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='schema_version'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__delitem__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__dict__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

mappingproxy({'__module__': 'kittycad.models.ai_plugin_manifest', '__annotations__': {'api': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api.AiPluginApi], 'auth': typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth.AiPluginAuth], 'contact_email': typing.Union[kittycad.types.Unset, str], 'description_for_human': typing.Union[kittycad.types.Unset, str], 'description_for_model': typing.Union[kittycad.types.Unset, str], 'legal_info_url': typing.Union[kittycad.types.Unset, str], 'logo_url': typing.Union[kittycad.types.Unset, str], 'name_for_human': typing.Union[kittycad.types.Unset, str], 'name_for_model': typing.Union[kittycad.types.Unset, str], 'schema_version': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "AI plugin manifest.\n\n    This is used for OpenAI's ChatGPT plugins. You can read more about them [here](https://platform.openai.com/docs/plugins/getting-started/plugin-manifest).\n    ", 'to_dict': <function AiPluginManifest.to_dict>, 'from_dict': <classmethod(<function AiPluginManifest.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AiPluginManifest.__getitem__>, '__setitem__': <function AiPluginManifest.__setitem__>, '__delitem__': <function AiPluginManifest.__delitem__>, '__contains__': <function AiPluginManifest.__contains__>, '__dict__': <attribute '__dict__' of 'AiPluginManifest' objects>, '__weakref__': <attribute '__weakref__' of 'AiPluginManifest' objects>, '__attrs_attrs__': (Attribute(name='api', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_api.AiPluginApi], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='api'), Attribute(name='auth', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.ai_plugin_auth.AiPluginAuth], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth'), Attribute(name='contact_email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='contact_email'), Attribute(name='description_for_human', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description_for_human'), Attribute(name='description_for_model', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description_for_model'), Attribute(name='legal_info_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='legal_info_url'), Attribute(name='logo_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='logo_url'), Attribute(name='name_for_human', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name_for_human'), Attribute(name='name_for_model', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name_for_model'), Attribute(name='schema_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='schema_version'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AiPluginManifest.__repr__>, '__eq__': <function AiPluginManifest.__eq__>, '__ne__': <function AiPluginManifest.__ne__>, '__lt__': <function AiPluginManifest.__lt__>, '__le__': <function AiPluginManifest.__le__>, '__gt__': <function AiPluginManifest.__gt__>, '__ge__': <function AiPluginManifest.__ge__>, '__hash__': None, '__init__': <function AiPluginManifest.__init__>, '__match_args__': ('api', 'auth', 'contact_email', 'description_for_human', 'description_for_model', 'legal_info_url', 'logo_url', 'name_for_human', 'name_for_model', 'schema_version')})

__eq__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__ge__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__getitem__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__gt__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__hash__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

__init__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

AiPluginManifest.__init__(api=<kittycad.types.Unset object>, auth=<kittycad.types.Unset object>, contact_email=<kittycad.types.Unset object>, description_for_human=<kittycad.types.Unset object>, description_for_model=<kittycad.types.Unset object>, legal_info_url=<kittycad.types.Unset object>, logo_url=<kittycad.types.Unset object>, name_for_human=<kittycad.types.Unset object>, name_for_model=<kittycad.types.Unset object>, schema_version=<kittycad.types.Unset object>)

__le__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__lt__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__match_args__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

('api', 'auth', 'contact_email', 'description_for_human', 'description_for_model', 'legal_info_url', 'logo_url', 'name_for_human', 'name_for_model', 'schema_version')

__module__ (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

__ne__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__repr__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__setitem__() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

additional_keys (kittycad.models.ai_plugin_manifest.AiPluginManifest property)

api (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

auth (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

contact_email (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

from_dict() (kittycad.models.ai_plugin_manifest.AiPluginManifest class method)

legal_info_url (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

logo_url (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

name_for_human (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

name_for_model (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

schema_version (kittycad.models.ai_plugin_manifest.AiPluginManifest attribute)

to_dict() (kittycad.models.ai_plugin_manifest.AiPluginManifest method)

__init__([api, auth, contact_email, ...])

Method generated by attrs for class AiPluginManifest.

rtype

TypeVar(SA, bound= AiPluginManifest)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ai_plugin_manifest.AiPluginManifest.__init__>`\ \(\[api\, auth\, contact\_email\, ...\]\)

api

auth

contact_email

description_for_human

description_for_model

legal_info_url

logo_url

name_for_human

name_for_model

schema_version

AnnotationLineEnd(value[, names, module, ...])

Annotation line end type

:py:obj:`AnnotationLineEnd <kittycad.models.annotation_line_end.AnnotationLineEnd>`\ \(value\[\, names\, module\, ...\]\)

AnnotationLineEnd (class in kittycad.models.annotation_line_end)

AnnotationLineEnd(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

ARROW (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

NONE (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

__add__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__contains__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__dict__ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.annotation_line_end', '__doc__': 'Annotation line end type', '__str__': <function AnnotationLineEnd.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['NONE', 'ARROW'], '_member_map_': {'NONE': <AnnotationLineEnd.NONE: 'none'>, 'ARROW': <AnnotationLineEnd.ARROW: 'arrow'>}, '_value2member_map_': {'none': <AnnotationLineEnd.NONE: 'none'>, 'arrow': <AnnotationLineEnd.ARROW: 'arrow'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AnnotationLineEnd' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationLineEnd' objects>, 'NONE': <AnnotationLineEnd.NONE: 'none'>, 'ARROW': <AnnotationLineEnd.ARROW: 'arrow'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__eq__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__format__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__ge__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__getitem__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__getnewargs__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__gt__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__hash__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__init__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__iter__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__le__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__len__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__lt__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__mod__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__module__ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

__mul__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__ne__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__new__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__reduce_ex__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__repr__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__rmod__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__rmul__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__sizeof__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

__str__() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

AnnotationLineEnd._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

{'ARROW': AnnotationLineEnd.ARROW, 'NONE': AnnotationLineEnd.NONE}

_member_names_ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

_member_type_ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

_new_member_() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

_use_args_ (kittycad.models.annotation_line_end.AnnotationLineEnd attribute)

{'arrow': AnnotationLineEnd.ARROW, 'none': AnnotationLineEnd.NONE}

_value_repr_() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

capitalize() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

casefold() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

center() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

count() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

encode() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

endswith() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

expandtabs() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

find() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

format() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

format_map() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

index() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isalnum() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isalpha() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isascii() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isdecimal() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isdigit() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isidentifier() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

islower() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isnumeric() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isprintable() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isspace() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

istitle() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

isupper() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

join() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

ljust() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

lower() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

lstrip() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

maketrans() (kittycad.models.annotation_line_end.AnnotationLineEnd static method)

partition() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

removeprefix() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

removesuffix() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

replace() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rfind() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rindex() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rjust() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rpartition() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rsplit() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

rstrip() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

split() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

splitlines() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

startswith() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

strip() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

swapcase() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

title() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

translate() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

upper() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

zfill() (kittycad.models.annotation_line_end.AnnotationLineEnd method)

:py:obj:`__init__ <kittycad.models.annotation_line_end.AnnotationLineEnd.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.annotation_line_end.AnnotationLineEnd.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.annotation_line_end.AnnotationLineEnd.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.annotation_line_end.AnnotationLineEnd.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.annotation_line_end.AnnotationLineEnd.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.annotation_line_end.AnnotationLineEnd.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.annotation_line_end.AnnotationLineEnd.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.annotation_line_end.AnnotationLineEnd.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.annotation_line_end.AnnotationLineEnd.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.annotation_line_end.AnnotationLineEnd.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.annotation_line_end.AnnotationLineEnd.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.annotation_line_end.AnnotationLineEnd.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.annotation_line_end.AnnotationLineEnd.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.annotation_line_end.AnnotationLineEnd.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.annotation_line_end.AnnotationLineEnd.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.annotation_line_end.AnnotationLineEnd.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.annotation_line_end.AnnotationLineEnd.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.annotation_line_end.AnnotationLineEnd.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.annotation_line_end.AnnotationLineEnd.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.annotation_line_end.AnnotationLineEnd.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.annotation_line_end.AnnotationLineEnd.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.annotation_line_end.AnnotationLineEnd.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.annotation_line_end.AnnotationLineEnd.zfill>`\ \(width\, \/\)

AnnotationLineEndOptions([end, start])

Options for annotation text

AnnotationLineEndOptions (class in kittycad.models.annotation_line_end_options)

AnnotationLineEndOptions(end=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>)

(end=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'end': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], 'start': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd]}

(Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='start'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.annotation_line_end_options', '__annotations__': {'end': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], 'start': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Options for annotation text', 'to_dict': <function AnnotationLineEndOptions.to_dict>, 'from_dict': <classmethod(<function AnnotationLineEndOptions.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AnnotationLineEndOptions.__getitem__>, '__setitem__': <function AnnotationLineEndOptions.__setitem__>, '__delitem__': <function AnnotationLineEndOptions.__delitem__>, '__contains__': <function AnnotationLineEndOptions.__contains__>, '__dict__': <attribute '__dict__' of 'AnnotationLineEndOptions' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationLineEndOptions' objects>, '__attrs_attrs__': (Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end.AnnotationLineEnd], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='start'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AnnotationLineEndOptions.__repr__>, '__eq__': <function AnnotationLineEndOptions.__eq__>, '__ne__': <function AnnotationLineEndOptions.__ne__>, '__lt__': <function AnnotationLineEndOptions.__lt__>, '__le__': <function AnnotationLineEndOptions.__le__>, '__gt__': <function AnnotationLineEndOptions.__gt__>, '__ge__': <function AnnotationLineEndOptions.__ge__>, '__hash__': None, '__init__': <function AnnotationLineEndOptions.__init__>, '__match_args__': ('end', 'start')})

AnnotationLineEndOptions.__init__(end=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>)

from_dict() (kittycad.models.annotation_line_end_options.AnnotationLineEndOptions class method)

__init__([end, start])

Method generated by attrs for class AnnotationLineEndOptions.

rtype

TypeVar(GO, bound= AnnotationLineEndOptions)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.annotation_line_end_options.AnnotationLineEndOptions.__init__>`\ \(\[end\, start\]\)

:py:class:`~typing.TypeVar`\(``GO``, bound= AnnotationLineEndOptions)

AnnotationOptions([color, line_ends, ...])

Options for annotations

:py:obj:`AnnotationOptions <kittycad.models.annotation_options.AnnotationOptions>`\ \(\[color\, line\_ends\, ...\]\)

AnnotationOptions(color=<kittycad.types.Unset object>, line_ends=<kittycad.types.Unset object>, line_width=<kittycad.types.Unset object>, position=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>)

(color=<kittycad.types.Unset object>, line_ends=<kittycad.types.Unset object>, line_width=<kittycad.types.Unset object>, position=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.annotation_options.AnnotationOptions attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'color': typing.Union[kittycad.types.Unset, kittycad.models.color.Color], 'line_ends': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end_options.AnnotationLineEndOptions], 'line_width': typing.Union[kittycad.types.Unset, float], 'position': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'text': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_options.AnnotationTextOptions]}

__attrs_attrs__ (kittycad.models.annotation_options.AnnotationOptions attribute)

(Attribute(name='color', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.color.Color], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='color'), Attribute(name='line_ends', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end_options.AnnotationLineEndOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='line_ends'), Attribute(name='line_width', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='line_width'), Attribute(name='position', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='position'), Attribute(name='text', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_options.AnnotationTextOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='text'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.annotation_options.AnnotationOptions method)

__delitem__() (kittycad.models.annotation_options.AnnotationOptions method)

__dict__ (kittycad.models.annotation_options.AnnotationOptions attribute)

mappingproxy({'__module__': 'kittycad.models.annotation_options', '__annotations__': {'color': typing.Union[kittycad.types.Unset, kittycad.models.color.Color], 'line_ends': typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end_options.AnnotationLineEndOptions], 'line_width': typing.Union[kittycad.types.Unset, float], 'position': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'text': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_options.AnnotationTextOptions], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Options for annotations', 'to_dict': <function AnnotationOptions.to_dict>, 'from_dict': <classmethod(<function AnnotationOptions.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AnnotationOptions.__getitem__>, '__setitem__': <function AnnotationOptions.__setitem__>, '__delitem__': <function AnnotationOptions.__delitem__>, '__contains__': <function AnnotationOptions.__contains__>, '__dict__': <attribute '__dict__' of 'AnnotationOptions' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationOptions' objects>, '__attrs_attrs__': (Attribute(name='color', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.color.Color], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='color'), Attribute(name='line_ends', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_line_end_options.AnnotationLineEndOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='line_ends'), Attribute(name='line_width', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='line_width'), Attribute(name='position', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='position'), Attribute(name='text', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_options.AnnotationTextOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='text'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AnnotationOptions.__repr__>, '__eq__': <function AnnotationOptions.__eq__>, '__ne__': <function AnnotationOptions.__ne__>, '__lt__': <function AnnotationOptions.__lt__>, '__le__': <function AnnotationOptions.__le__>, '__gt__': <function AnnotationOptions.__gt__>, '__ge__': <function AnnotationOptions.__ge__>, '__hash__': None, '__init__': <function AnnotationOptions.__init__>, '__match_args__': ('color', 'line_ends', 'line_width', 'position', 'text')})

__eq__() (kittycad.models.annotation_options.AnnotationOptions method)

__ge__() (kittycad.models.annotation_options.AnnotationOptions method)

__getitem__() (kittycad.models.annotation_options.AnnotationOptions method)

__gt__() (kittycad.models.annotation_options.AnnotationOptions method)

__hash__ (kittycad.models.annotation_options.AnnotationOptions attribute)

__init__() (kittycad.models.annotation_options.AnnotationOptions method)

AnnotationOptions.__init__(color=<kittycad.types.Unset object>, line_ends=<kittycad.types.Unset object>, line_width=<kittycad.types.Unset object>, position=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>)

__le__() (kittycad.models.annotation_options.AnnotationOptions method)

__lt__() (kittycad.models.annotation_options.AnnotationOptions method)

__match_args__ (kittycad.models.annotation_options.AnnotationOptions attribute)

__module__ (kittycad.models.annotation_options.AnnotationOptions attribute)

__ne__() (kittycad.models.annotation_options.AnnotationOptions method)

__repr__() (kittycad.models.annotation_options.AnnotationOptions method)

__setitem__() (kittycad.models.annotation_options.AnnotationOptions method)

additional_keys (kittycad.models.annotation_options.AnnotationOptions property)

color (kittycad.models.annotation_options.AnnotationOptions attribute)

from_dict() (kittycad.models.annotation_options.AnnotationOptions class method)

line_ends (kittycad.models.annotation_options.AnnotationOptions attribute)

line_width (kittycad.models.annotation_options.AnnotationOptions attribute)

position (kittycad.models.annotation_options.AnnotationOptions attribute)

text (kittycad.models.annotation_options.AnnotationOptions attribute)

to_dict() (kittycad.models.annotation_options.AnnotationOptions method)

__init__([color, line_ends, line_width, ...])

Method generated by attrs for class AnnotationOptions.

rtype

TypeVar(PI, bound= AnnotationOptions)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.annotation_options.AnnotationOptions.__init__>`\ \(\[color\, line\_ends\, line\_width\, ...\]\)

color

line_ends

line_width

position

text

AnnotationTextAlignmentX(value[, names, ...])

Horizontal Text aligment

:py:obj:`AnnotationTextAlignmentX <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX>`\ \(value\[\, names\, ...\]\)

AnnotationTextAlignmentX (class in kittycad.models.annotation_text_alignment_x)

AnnotationTextAlignmentX(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.annotation_text_alignment_x', '__doc__': 'Horizontal Text aligment', '__str__': <function AnnotationTextAlignmentX.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['LEFT', 'CENTER', 'RIGHT'], '_member_map_': {'LEFT': <AnnotationTextAlignmentX.LEFT: 'left'>, 'CENTER': <AnnotationTextAlignmentX.CENTER: 'center'>, 'RIGHT': <AnnotationTextAlignmentX.RIGHT: 'right'>}, '_value2member_map_': {'left': <AnnotationTextAlignmentX.LEFT: 'left'>, 'center': <AnnotationTextAlignmentX.CENTER: 'center'>, 'right': <AnnotationTextAlignmentX.RIGHT: 'right'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AnnotationTextAlignmentX' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationTextAlignmentX' objects>, 'LEFT': <AnnotationTextAlignmentX.LEFT: 'left'>, 'CENTER': <AnnotationTextAlignmentX.CENTER: 'center'>, 'RIGHT': <AnnotationTextAlignmentX.RIGHT: 'right'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

AnnotationTextAlignmentX._generate_next_value_(start, count, last_values)

{'CENTER': AnnotationTextAlignmentX.CENTER, 'LEFT': AnnotationTextAlignmentX.LEFT, 'RIGHT': AnnotationTextAlignmentX.RIGHT}

{'center': AnnotationTextAlignmentX.CENTER, 'left': AnnotationTextAlignmentX.LEFT, 'right': AnnotationTextAlignmentX.RIGHT}

AnnotationTextAlignmentX.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX static method)

AnnotationTextAlignmentX.startswith(prefix[, start[, end]]) -> bool

:py:obj:`center <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`endswith <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.partition>`\ \(sep\, \/\)

:py:obj:`replace <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX.zfill>`\ \(width\, \/\)

AnnotationTextAlignmentY(value[, names, ...])

Vertical Text aligment

:py:obj:`AnnotationTextAlignmentY <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY>`\ \(value\[\, names\, ...\]\)

AnnotationTextAlignmentY (class in kittycad.models.annotation_text_alignment_y)

AnnotationTextAlignmentY(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.annotation_text_alignment_y', '__doc__': 'Vertical Text aligment', '__str__': <function AnnotationTextAlignmentY.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['BOTTOM', 'CENTER', 'TOP'], '_member_map_': {'BOTTOM': <AnnotationTextAlignmentY.BOTTOM: 'bottom'>, 'CENTER': <AnnotationTextAlignmentY.CENTER: 'center'>, 'TOP': <AnnotationTextAlignmentY.TOP: 'top'>}, '_value2member_map_': {'bottom': <AnnotationTextAlignmentY.BOTTOM: 'bottom'>, 'center': <AnnotationTextAlignmentY.CENTER: 'center'>, 'top': <AnnotationTextAlignmentY.TOP: 'top'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AnnotationTextAlignmentY' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationTextAlignmentY' objects>, 'BOTTOM': <AnnotationTextAlignmentY.BOTTOM: 'bottom'>, 'CENTER': <AnnotationTextAlignmentY.CENTER: 'center'>, 'TOP': <AnnotationTextAlignmentY.TOP: 'top'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

AnnotationTextAlignmentY._generate_next_value_(start, count, last_values)

{'BOTTOM': AnnotationTextAlignmentY.BOTTOM, 'CENTER': AnnotationTextAlignmentY.CENTER, 'TOP': AnnotationTextAlignmentY.TOP}

{'bottom': AnnotationTextAlignmentY.BOTTOM, 'center': AnnotationTextAlignmentY.CENTER, 'top': AnnotationTextAlignmentY.TOP}

AnnotationTextAlignmentY.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY static method)

AnnotationTextAlignmentY.startswith(prefix[, start[, end]]) -> bool

:py:obj:`center <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`endswith <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.partition>`\ \(sep\, \/\)

:py:obj:`replace <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY.zfill>`\ \(width\, \/\)

AnnotationTextOptions([point_size, text, x, y])

:py:obj:`AnnotationTextOptions <kittycad.models.annotation_text_options.AnnotationTextOptions>`\ \(\[point\_size\, text\, x\, y\]\)

AnnotationTextOptions (class in kittycad.models.annotation_text_options)

AnnotationTextOptions(point_size=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>, x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

(point_size=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>, x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'point_size': typing.Union[kittycad.types.Unset, int], 'text': typing.Union[kittycad.types.Unset, str], 'x': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX], 'y': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY]}

(Attribute(name='point_size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='point_size'), Attribute(name='text', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='text'), Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.annotation_text_options', '__annotations__': {'point_size': typing.Union[kittycad.types.Unset, int], 'text': typing.Union[kittycad.types.Unset, str], 'x': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX], 'y': typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Options for annotation text', 'to_dict': <function AnnotationTextOptions.to_dict>, 'from_dict': <classmethod(<function AnnotationTextOptions.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AnnotationTextOptions.__getitem__>, '__setitem__': <function AnnotationTextOptions.__setitem__>, '__delitem__': <function AnnotationTextOptions.__delitem__>, '__contains__': <function AnnotationTextOptions.__contains__>, '__dict__': <attribute '__dict__' of 'AnnotationTextOptions' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationTextOptions' objects>, '__attrs_attrs__': (Attribute(name='point_size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='point_size'), Attribute(name='text', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='text'), Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_x.AnnotationTextAlignmentX], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_text_alignment_y.AnnotationTextAlignmentY], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AnnotationTextOptions.__repr__>, '__eq__': <function AnnotationTextOptions.__eq__>, '__ne__': <function AnnotationTextOptions.__ne__>, '__lt__': <function AnnotationTextOptions.__lt__>, '__le__': <function AnnotationTextOptions.__le__>, '__gt__': <function AnnotationTextOptions.__gt__>, '__ge__': <function AnnotationTextOptions.__ge__>, '__hash__': None, '__init__': <function AnnotationTextOptions.__init__>, '__match_args__': ('point_size', 'text', 'x', 'y')})

__eq__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

__ge__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

__gt__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

AnnotationTextOptions.__init__(point_size=<kittycad.types.Unset object>, text=<kittycad.types.Unset object>, x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

__le__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

__lt__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

__ne__() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

from_dict() (kittycad.models.annotation_text_options.AnnotationTextOptions class method)

text (kittycad.models.annotation_text_options.AnnotationTextOptions attribute)

to_dict() (kittycad.models.annotation_text_options.AnnotationTextOptions method)

x (kittycad.models.annotation_text_options.AnnotationTextOptions attribute)

y (kittycad.models.annotation_text_options.AnnotationTextOptions attribute)

__init__([point_size, text, x, y])

Method generated by attrs for class AnnotationTextOptions.

rtype

TypeVar(UZ, bound= AnnotationTextOptions)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.annotation_text_options.AnnotationTextOptions.__init__>`\ \(\[point\_size\, text\, x\, y\]\)

:py:class:`~typing.TypeVar`\(``UZ``, bound= AnnotationTextOptions)

point_size

text

x

y

AnnotationType(value[, names, module, ...])

The type of annotation

:py:obj:`AnnotationType <kittycad.models.annotation_type.AnnotationType>`\ \(value\[\, names\, module\, ...\]\)

AnnotationType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__add__() (kittycad.models.annotation_type.AnnotationType method)

__annotations__ (kittycad.models.annotation_type.AnnotationType attribute)

__contains__() (kittycad.models.annotation_type.AnnotationType method)

__dict__ (kittycad.models.annotation_type.AnnotationType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.annotation_type', '__doc__': 'The type of annotation', '__str__': <function AnnotationType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['T2D', 'T3D'], '_member_map_': {'T2D': <AnnotationType.T2D: 't2d'>, 'T3D': <AnnotationType.T3D: 't3d'>}, '_value2member_map_': {'t2d': <AnnotationType.T2D: 't2d'>, 't3d': <AnnotationType.T3D: 't3d'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AnnotationType' objects>, '__weakref__': <attribute '__weakref__' of 'AnnotationType' objects>, 'T2D': <AnnotationType.T2D: 't2d'>, 'T3D': <AnnotationType.T3D: 't3d'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.annotation_type.AnnotationType method)

__eq__() (kittycad.models.annotation_type.AnnotationType method)

__format__() (kittycad.models.annotation_type.AnnotationType method)

__ge__() (kittycad.models.annotation_type.AnnotationType method)

__getattribute__() (kittycad.models.annotation_type.AnnotationType method)

__getitem__() (kittycad.models.annotation_type.AnnotationType method)

__getnewargs__() (kittycad.models.annotation_type.AnnotationType method)

__gt__() (kittycad.models.annotation_type.AnnotationType method)

__hash__() (kittycad.models.annotation_type.AnnotationType method)

__init__() (kittycad.models.annotation_type.AnnotationType method)

__iter__() (kittycad.models.annotation_type.AnnotationType method)

__le__() (kittycad.models.annotation_type.AnnotationType method)

__len__() (kittycad.models.annotation_type.AnnotationType method)

__lt__() (kittycad.models.annotation_type.AnnotationType method)

__mod__() (kittycad.models.annotation_type.AnnotationType method)

__module__ (kittycad.models.annotation_type.AnnotationType attribute)

__mul__() (kittycad.models.annotation_type.AnnotationType method)

__ne__() (kittycad.models.annotation_type.AnnotationType method)

__new__() (kittycad.models.annotation_type.AnnotationType method)

__reduce_ex__() (kittycad.models.annotation_type.AnnotationType method)

__repr__() (kittycad.models.annotation_type.AnnotationType method)

__rmod__() (kittycad.models.annotation_type.AnnotationType method)

__rmul__() (kittycad.models.annotation_type.AnnotationType method)

__sizeof__() (kittycad.models.annotation_type.AnnotationType method)

__str__() (kittycad.models.annotation_type.AnnotationType method)

_generate_next_value_() (kittycad.models.annotation_type.AnnotationType method)

_member_map_ (kittycad.models.annotation_type.AnnotationType attribute)

_member_names_ (kittycad.models.annotation_type.AnnotationType attribute)

_member_type_ (kittycad.models.annotation_type.AnnotationType attribute)

_new_member_() (kittycad.models.annotation_type.AnnotationType method)

_unhashable_values_ (kittycad.models.annotation_type.AnnotationType attribute)

_use_args_ (kittycad.models.annotation_type.AnnotationType attribute)

_value2member_map_ (kittycad.models.annotation_type.AnnotationType attribute)

_value_repr_() (kittycad.models.annotation_type.AnnotationType method)

capitalize() (kittycad.models.annotation_type.AnnotationType method)

casefold() (kittycad.models.annotation_type.AnnotationType method)

center() (kittycad.models.annotation_type.AnnotationType method)

encode() (kittycad.models.annotation_type.AnnotationType method)

endswith() (kittycad.models.annotation_type.AnnotationType method)

expandtabs() (kittycad.models.annotation_type.AnnotationType method)

format() (kittycad.models.annotation_type.AnnotationType method)

format_map() (kittycad.models.annotation_type.AnnotationType method)

isalnum() (kittycad.models.annotation_type.AnnotationType method)

isalpha() (kittycad.models.annotation_type.AnnotationType method)

isascii() (kittycad.models.annotation_type.AnnotationType method)

isdecimal() (kittycad.models.annotation_type.AnnotationType method)

isdigit() (kittycad.models.annotation_type.AnnotationType method)

isidentifier() (kittycad.models.annotation_type.AnnotationType method)

islower() (kittycad.models.annotation_type.AnnotationType method)

isnumeric() (kittycad.models.annotation_type.AnnotationType method)

isprintable() (kittycad.models.annotation_type.AnnotationType method)

isspace() (kittycad.models.annotation_type.AnnotationType method)

istitle() (kittycad.models.annotation_type.AnnotationType method)

isupper() (kittycad.models.annotation_type.AnnotationType method)

lstrip() (kittycad.models.annotation_type.AnnotationType method)

maketrans() (kittycad.models.annotation_type.AnnotationType static method)

partition() (kittycad.models.annotation_type.AnnotationType method)

removeprefix() (kittycad.models.annotation_type.AnnotationType method)

removesuffix() (kittycad.models.annotation_type.AnnotationType method)

replace() (kittycad.models.annotation_type.AnnotationType method)

rindex() (kittycad.models.annotation_type.AnnotationType method)

rpartition() (kittycad.models.annotation_type.AnnotationType method)

rsplit() (kittycad.models.annotation_type.AnnotationType method)

rstrip() (kittycad.models.annotation_type.AnnotationType method)

splitlines() (kittycad.models.annotation_type.AnnotationType method)

startswith() (kittycad.models.annotation_type.AnnotationType method)

swapcase() (kittycad.models.annotation_type.AnnotationType method)

translate() (kittycad.models.annotation_type.AnnotationType method)

:py:obj:`__init__ <kittycad.models.annotation_type.AnnotationType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.annotation_type.AnnotationType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.annotation_type.AnnotationType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.annotation_type.AnnotationType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.annotation_type.AnnotationType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.annotation_type.AnnotationType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.annotation_type.AnnotationType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.annotation_type.AnnotationType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.annotation_type.AnnotationType.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.annotation_type.AnnotationType.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.annotation_type.AnnotationType.isascii>`\ \(\)

:py:obj:`isdigit <kittycad.models.annotation_type.AnnotationType.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.annotation_type.AnnotationType.islower>`\ \(\)

:py:obj:`isspace <kittycad.models.annotation_type.AnnotationType.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.annotation_type.AnnotationType.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.annotation_type.AnnotationType.isupper>`\ \(\)

:py:obj:`join <kittycad.models.annotation_type.AnnotationType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.annotation_type.AnnotationType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.annotation_type.AnnotationType.lower>`\ \(\)

:py:obj:`partition <kittycad.models.annotation_type.AnnotationType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.annotation_type.AnnotationType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.annotation_type.AnnotationType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.annotation_type.AnnotationType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.annotation_type.AnnotationType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.annotation_type.AnnotationType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.annotation_type.AnnotationType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.annotation_type.AnnotationType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.annotation_type.AnnotationType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.annotation_type.AnnotationType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.annotation_type.AnnotationType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.annotation_type.AnnotationType.title>`\ \(\)

:py:obj:`translate <kittycad.models.annotation_type.AnnotationType.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.annotation_type.AnnotationType.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.annotation_type.AnnotationType.zfill>`\ \(width\, \/\)

ApiCallQueryGroup([count, query])

A response for a query on the API call table that is grouped by something.

:py:obj:`ApiCallQueryGroup <kittycad.models.api_call_query_group.ApiCallQueryGroup>`\ \(\[count\, query\]\)

ApiCallQueryGroup (class in kittycad.models.api_call_query_group)

ApiCallQueryGroup(count=<kittycad.types.Unset object>, query=<kittycad.types.Unset object>)

(count=<kittycad.types.Unset object>, query=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'count': typing.Union[kittycad.types.Unset, int], 'query': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='count', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='count'), Attribute(name='query', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='query'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__delitem__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__dict__ (kittycad.models.api_call_query_group.ApiCallQueryGroup attribute)

mappingproxy({'__module__': 'kittycad.models.api_call_query_group', '__annotations__': {'count': typing.Union[kittycad.types.Unset, int], 'query': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A response for a query on the API call table that is grouped by something.', 'to_dict': <function ApiCallQueryGroup.to_dict>, 'from_dict': <classmethod(<function ApiCallQueryGroup.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ApiCallQueryGroup.__getitem__>, '__setitem__': <function ApiCallQueryGroup.__setitem__>, '__delitem__': <function ApiCallQueryGroup.__delitem__>, '__contains__': <function ApiCallQueryGroup.__contains__>, '__dict__': <attribute '__dict__' of 'ApiCallQueryGroup' objects>, '__weakref__': <attribute '__weakref__' of 'ApiCallQueryGroup' objects>, '__attrs_attrs__': (Attribute(name='count', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='count'), Attribute(name='query', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='query'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ApiCallQueryGroup.__repr__>, '__eq__': <function ApiCallQueryGroup.__eq__>, '__ne__': <function ApiCallQueryGroup.__ne__>, '__lt__': <function ApiCallQueryGroup.__lt__>, '__le__': <function ApiCallQueryGroup.__le__>, '__gt__': <function ApiCallQueryGroup.__gt__>, '__ge__': <function ApiCallQueryGroup.__ge__>, '__hash__': None, '__init__': <function ApiCallQueryGroup.__init__>, '__match_args__': ('count', 'query')})

__eq__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__ge__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__getitem__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__gt__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__hash__ (kittycad.models.api_call_query_group.ApiCallQueryGroup attribute)

__init__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

ApiCallQueryGroup.__init__(count=<kittycad.types.Unset object>, query=<kittycad.types.Unset object>)

__le__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__lt__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__module__ (kittycad.models.api_call_query_group.ApiCallQueryGroup attribute)

__ne__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__repr__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__setitem__() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

count (kittycad.models.api_call_query_group.ApiCallQueryGroup attribute)

from_dict() (kittycad.models.api_call_query_group.ApiCallQueryGroup class method)

query (kittycad.models.api_call_query_group.ApiCallQueryGroup attribute)

to_dict() (kittycad.models.api_call_query_group.ApiCallQueryGroup method)

__init__([count, query])

Method generated by attrs for class ApiCallQueryGroup.

rtype

TypeVar(FB, bound= ApiCallQueryGroup)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.api_call_query_group.ApiCallQueryGroup.__init__>`\ \(\[count\, query\]\)

count

query

ApiCallQueryGroupBy(value[, names, module, ...])

The field of an API call to group by.

:py:obj:`ApiCallQueryGroupBy <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy>`\ \(value\[\, names\, module\, ...\]\)

ApiCallQueryGroupBy (class in kittycad.models.api_call_query_group_by)

ApiCallQueryGroupBy(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

EMAIL (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

docstring of kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.EMAIL

ENDPOINT (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

METHOD (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

docstring of kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.METHOD

ORIGIN (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

docstring of kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.ORIGIN

USER_ID (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

docstring of kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.USER_ID

# The origin of the API call. This is parsed from the `Origin` header.

__add__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__dict__ (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.api_call_query_group_by', '__doc__': 'The field of an API call to group by.', '__str__': <function ApiCallQueryGroupBy.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['EMAIL', 'METHOD', 'ENDPOINT', 'USER_ID', 'ORIGIN', 'IP_ADDRESS'], '_member_map_': {'EMAIL': <ApiCallQueryGroupBy.EMAIL: 'email'>, 'METHOD': <ApiCallQueryGroupBy.METHOD: 'method'>, 'ENDPOINT': <ApiCallQueryGroupBy.ENDPOINT: 'endpoint'>, 'USER_ID': <ApiCallQueryGroupBy.USER_ID: 'user_id'>, 'ORIGIN': <ApiCallQueryGroupBy.ORIGIN: 'origin'>, 'IP_ADDRESS': <ApiCallQueryGroupBy.IP_ADDRESS: 'ip_address'>}, '_value2member_map_': {'email': <ApiCallQueryGroupBy.EMAIL: 'email'>, 'method': <ApiCallQueryGroupBy.METHOD: 'method'>, 'endpoint': <ApiCallQueryGroupBy.ENDPOINT: 'endpoint'>, 'user_id': <ApiCallQueryGroupBy.USER_ID: 'user_id'>, 'origin': <ApiCallQueryGroupBy.ORIGIN: 'origin'>, 'ip_address': <ApiCallQueryGroupBy.IP_ADDRESS: 'ip_address'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'ApiCallQueryGroupBy' objects>, '__weakref__': <attribute '__weakref__' of 'ApiCallQueryGroupBy' objects>, 'EMAIL': <ApiCallQueryGroupBy.EMAIL: 'email'>, 'METHOD': <ApiCallQueryGroupBy.METHOD: 'method'>, 'ENDPOINT': <ApiCallQueryGroupBy.ENDPOINT: 'endpoint'>, 'USER_ID': <ApiCallQueryGroupBy.USER_ID: 'user_id'>, 'ORIGIN': <ApiCallQueryGroupBy.ORIGIN: 'origin'>, 'IP_ADDRESS': <ApiCallQueryGroupBy.IP_ADDRESS: 'ip_address'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__eq__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__ge__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__gt__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__hash__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__init__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__iter__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__le__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__len__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__lt__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__mod__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__mul__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__ne__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__new__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__repr__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__rmod__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__rmul__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

__str__() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

ApiCallQueryGroupBy._generate_next_value_(start, count, last_values)

{'EMAIL': ApiCallQueryGroupBy.EMAIL, 'ENDPOINT': ApiCallQueryGroupBy.ENDPOINT, 'IP_ADDRESS': ApiCallQueryGroupBy.IP_ADDRESS, 'METHOD': ApiCallQueryGroupBy.METHOD, 'ORIGIN': ApiCallQueryGroupBy.ORIGIN, 'USER_ID': ApiCallQueryGroupBy.USER_ID}

['EMAIL', 'METHOD', 'ENDPOINT', 'USER_ID', 'ORIGIN', 'IP_ADDRESS']

{'email': ApiCallQueryGroupBy.EMAIL, 'endpoint': ApiCallQueryGroupBy.ENDPOINT, 'ip_address': ApiCallQueryGroupBy.IP_ADDRESS, 'method': ApiCallQueryGroupBy.METHOD, 'origin': ApiCallQueryGroupBy.ORIGIN, 'user_id': ApiCallQueryGroupBy.USER_ID}

casefold() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

center() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

count() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

encode() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

endswith() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

find() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

format() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

index() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isalnum() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isalpha() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isascii() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isdecimal() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isdigit() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

islower() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isnumeric() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isspace() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

istitle() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

isupper() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

join() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

ljust() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

lower() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

lstrip() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

maketrans() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy static method)

partition() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

replace() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

rfind() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

rindex() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

rjust() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

rsplit() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

rstrip() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

split() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

strip() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

swapcase() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

title() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

translate() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

upper() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

zfill() (kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy method)

:py:obj:`__init__ <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.api_call_query_group_by.ApiCallQueryGroupBy.zfill>`\ \(width\, \/\)

EMAIL

# The HTTP method of the API call.

METHOD

# The endpoint of the API call.

ENDPOINT

# The user ID of the user that requested the API call.

USER_ID

# The origin of the API call.

ORIGIN

# The IP address of the user making the API call.

IP_ADDRESS

ApiCallStatus(value[, names, module, ...])

The status of an async API call.

:py:obj:`ApiCallStatus <kittycad.models.api_call_status.ApiCallStatus>`\ \(value\[\, names\, module\, ...\]\)

ApiCallStatus(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

COMPLETED (kittycad.models.api_call_status.ApiCallStatus attribute)

docstring of kittycad.models.api_call_status.ApiCallStatus.COMPLETED

FAILED (kittycad.models.api_call_status.ApiCallStatus attribute)

IN_PROGRESS (kittycad.models.api_call_status.ApiCallStatus attribute)

docstring of kittycad.models.api_call_status.ApiCallStatus.IN_PROGRESS

QUEUED (kittycad.models.api_call_status.ApiCallStatus attribute)

docstring of kittycad.models.api_call_status.ApiCallStatus.QUEUED

UPLOADED (kittycad.models.api_call_status.ApiCallStatus attribute)

docstring of kittycad.models.api_call_status.ApiCallStatus.UPLOADED

__add__() (kittycad.models.api_call_status.ApiCallStatus method)

__annotations__ (kittycad.models.api_call_status.ApiCallStatus attribute)

__contains__() (kittycad.models.api_call_status.ApiCallStatus method)

__dict__ (kittycad.models.api_call_status.ApiCallStatus attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.api_call_status', '__doc__': 'The status of an async API call.', '__str__': <function ApiCallStatus.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['QUEUED', 'UPLOADED', 'IN_PROGRESS', 'COMPLETED', 'FAILED'], '_member_map_': {'QUEUED': <ApiCallStatus.QUEUED: 'Queued'>, 'UPLOADED': <ApiCallStatus.UPLOADED: 'Uploaded'>, 'IN_PROGRESS': <ApiCallStatus.IN_PROGRESS: 'In Progress'>, 'COMPLETED': <ApiCallStatus.COMPLETED: 'Completed'>, 'FAILED': <ApiCallStatus.FAILED: 'Failed'>}, '_value2member_map_': {'Queued': <ApiCallStatus.QUEUED: 'Queued'>, 'Uploaded': <ApiCallStatus.UPLOADED: 'Uploaded'>, 'In Progress': <ApiCallStatus.IN_PROGRESS: 'In Progress'>, 'Completed': <ApiCallStatus.COMPLETED: 'Completed'>, 'Failed': <ApiCallStatus.FAILED: 'Failed'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'ApiCallStatus' objects>, '__weakref__': <attribute '__weakref__' of 'ApiCallStatus' objects>, 'QUEUED': <ApiCallStatus.QUEUED: 'Queued'>, 'UPLOADED': <ApiCallStatus.UPLOADED: 'Uploaded'>, 'IN_PROGRESS': <ApiCallStatus.IN_PROGRESS: 'In Progress'>, 'COMPLETED': <ApiCallStatus.COMPLETED: 'Completed'>, 'FAILED': <ApiCallStatus.FAILED: 'Failed'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.api_call_status.ApiCallStatus method)

__format__() (kittycad.models.api_call_status.ApiCallStatus method)

__getattribute__() (kittycad.models.api_call_status.ApiCallStatus method)

__getitem__() (kittycad.models.api_call_status.ApiCallStatus method)

__getnewargs__() (kittycad.models.api_call_status.ApiCallStatus method)

__hash__() (kittycad.models.api_call_status.ApiCallStatus method)

__init__() (kittycad.models.api_call_status.ApiCallStatus method)

__iter__() (kittycad.models.api_call_status.ApiCallStatus method)

__len__() (kittycad.models.api_call_status.ApiCallStatus method)

__mod__() (kittycad.models.api_call_status.ApiCallStatus method)

__module__ (kittycad.models.api_call_status.ApiCallStatus attribute)

__mul__() (kittycad.models.api_call_status.ApiCallStatus method)

__new__() (kittycad.models.api_call_status.ApiCallStatus method)

__reduce_ex__() (kittycad.models.api_call_status.ApiCallStatus method)

__repr__() (kittycad.models.api_call_status.ApiCallStatus method)

__rmod__() (kittycad.models.api_call_status.ApiCallStatus method)

__rmul__() (kittycad.models.api_call_status.ApiCallStatus method)

__sizeof__() (kittycad.models.api_call_status.ApiCallStatus method)

__str__() (kittycad.models.api_call_status.ApiCallStatus method)

_generate_next_value_() (kittycad.models.api_call_status.ApiCallStatus method)

_member_map_ (kittycad.models.api_call_status.ApiCallStatus attribute)

{'COMPLETED': ApiCallStatus.COMPLETED, 'FAILED': ApiCallStatus.FAILED, 'IN_PROGRESS': ApiCallStatus.IN_PROGRESS, 'QUEUED': ApiCallStatus.QUEUED, 'UPLOADED': ApiCallStatus.UPLOADED}

_member_names_ (kittycad.models.api_call_status.ApiCallStatus attribute)

_member_type_ (kittycad.models.api_call_status.ApiCallStatus attribute)

_new_member_() (kittycad.models.api_call_status.ApiCallStatus method)

_unhashable_values_ (kittycad.models.api_call_status.ApiCallStatus attribute)

_use_args_ (kittycad.models.api_call_status.ApiCallStatus attribute)

_value2member_map_ (kittycad.models.api_call_status.ApiCallStatus attribute)

{'Completed': ApiCallStatus.COMPLETED, 'Failed': ApiCallStatus.FAILED, 'In Progress': ApiCallStatus.IN_PROGRESS, 'Queued': ApiCallStatus.QUEUED, 'Uploaded': ApiCallStatus.UPLOADED}

_value_repr_() (kittycad.models.api_call_status.ApiCallStatus method)

capitalize() (kittycad.models.api_call_status.ApiCallStatus method)

casefold() (kittycad.models.api_call_status.ApiCallStatus method)

endswith() (kittycad.models.api_call_status.ApiCallStatus method)

expandtabs() (kittycad.models.api_call_status.ApiCallStatus method)

format_map() (kittycad.models.api_call_status.ApiCallStatus method)

isalnum() (kittycad.models.api_call_status.ApiCallStatus method)

isalpha() (kittycad.models.api_call_status.ApiCallStatus method)

isascii() (kittycad.models.api_call_status.ApiCallStatus method)

isdecimal() (kittycad.models.api_call_status.ApiCallStatus method)

isdigit() (kittycad.models.api_call_status.ApiCallStatus method)

isidentifier() (kittycad.models.api_call_status.ApiCallStatus method)

islower() (kittycad.models.api_call_status.ApiCallStatus method)

isnumeric() (kittycad.models.api_call_status.ApiCallStatus method)

isprintable() (kittycad.models.api_call_status.ApiCallStatus method)

isspace() (kittycad.models.api_call_status.ApiCallStatus method)

istitle() (kittycad.models.api_call_status.ApiCallStatus method)

isupper() (kittycad.models.api_call_status.ApiCallStatus method)

maketrans() (kittycad.models.api_call_status.ApiCallStatus static method)

partition() (kittycad.models.api_call_status.ApiCallStatus method)

removeprefix() (kittycad.models.api_call_status.ApiCallStatus method)

removesuffix() (kittycad.models.api_call_status.ApiCallStatus method)

replace() (kittycad.models.api_call_status.ApiCallStatus method)

rpartition() (kittycad.models.api_call_status.ApiCallStatus method)

splitlines() (kittycad.models.api_call_status.ApiCallStatus method)

startswith() (kittycad.models.api_call_status.ApiCallStatus method)

swapcase() (kittycad.models.api_call_status.ApiCallStatus method)

translate() (kittycad.models.api_call_status.ApiCallStatus method)

:py:obj:`__init__ <kittycad.models.api_call_status.ApiCallStatus.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.api_call_status.ApiCallStatus.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.api_call_status.ApiCallStatus.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.api_call_status.ApiCallStatus.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.api_call_status.ApiCallStatus.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.api_call_status.ApiCallStatus.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.api_call_status.ApiCallStatus.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.api_call_status.ApiCallStatus.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.api_call_status.ApiCallStatus.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.api_call_status.ApiCallStatus.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.api_call_status.ApiCallStatus.isascii>`\ \(\)

:py:obj:`isdigit <kittycad.models.api_call_status.ApiCallStatus.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.api_call_status.ApiCallStatus.islower>`\ \(\)

:py:obj:`isspace <kittycad.models.api_call_status.ApiCallStatus.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.api_call_status.ApiCallStatus.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.api_call_status.ApiCallStatus.isupper>`\ \(\)

:py:obj:`join <kittycad.models.api_call_status.ApiCallStatus.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.api_call_status.ApiCallStatus.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.api_call_status.ApiCallStatus.lower>`\ \(\)

:py:obj:`partition <kittycad.models.api_call_status.ApiCallStatus.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.api_call_status.ApiCallStatus.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.api_call_status.ApiCallStatus.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.api_call_status.ApiCallStatus.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.api_call_status.ApiCallStatus.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.api_call_status.ApiCallStatus.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.api_call_status.ApiCallStatus.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.api_call_status.ApiCallStatus.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.api_call_status.ApiCallStatus.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.api_call_status.ApiCallStatus.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.api_call_status.ApiCallStatus.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.api_call_status.ApiCallStatus.title>`\ \(\)

:py:obj:`translate <kittycad.models.api_call_status.ApiCallStatus.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.api_call_status.ApiCallStatus.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.api_call_status.ApiCallStatus.zfill>`\ \(width\, \/\)

QUEUED

# The async API call was uploaded to be converted.

UPLOADED

# The async API call is in progress.

IN_PROGRESS

# The async API call has completed.

COMPLETED

# The async API call has failed.

FAILED

ApiCallWithPrice([completed_at, created_at, ...])

An API call with the price.

:py:obj:`ApiCallWithPrice <kittycad.models.api_call_with_price.ApiCallWithPrice>`\ \(\[completed\_at\, created\_at\, ...\]\)

ApiCallWithPrice(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, duration=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, endpoint=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, ip_address=<kittycad.types.Unset object>, litterbox=False, method=<kittycad.types.Unset object>, minutes=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, price=<kittycad.types.Unset object>, request_body=<kittycad.types.Unset object>, request_query_params=<kittycad.types.Unset object>, response_body=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>, stripe_invoice_item_id=<kittycad.types.Unset object>, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_agent=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, duration=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, endpoint=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, ip_address=<kittycad.types.Unset object>, litterbox=False, method=<kittycad.types.Unset object>, minutes=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, price=<kittycad.types.Unset object>, request_body=<kittycad.types.Unset object>, request_query_params=<kittycad.types.Unset object>, response_body=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>, stripe_invoice_item_id=<kittycad.types.Unset object>, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_agent=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'duration': typing.Union[kittycad.types.Unset, int], 'email': typing.Union[kittycad.types.Unset, str], 'endpoint': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'ip_address': typing.Union[kittycad.types.Unset, str], 'litterbox': typing.Union[kittycad.types.Unset, bool], 'method': typing.Union[kittycad.types.Unset, kittycad.models.method.Method], 'minutes': typing.Union[kittycad.types.Unset, int], 'origin': typing.Union[kittycad.types.Unset, str], 'price': typing.Union[kittycad.types.Unset, float], 'request_body': typing.Union[kittycad.types.Unset, str], 'request_query_params': typing.Union[kittycad.types.Unset, str], 'response_body': typing.Union[kittycad.types.Unset, str], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status_code': typing.Union[kittycad.types.Unset, int], 'stripe_invoice_item_id': typing.Union[kittycad.types.Unset, str], 'token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_agent': typing.Union[kittycad.types.Unset, str], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='duration', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='duration'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='endpoint', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='endpoint'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='ip_address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ip_address'), Attribute(name='litterbox', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='litterbox'), Attribute(name='method', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.method.Method], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='method'), Attribute(name='minutes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='minutes'), Attribute(name='origin', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='origin'), Attribute(name='price', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='price'), Attribute(name='request_body', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_body'), Attribute(name='request_query_params', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_query_params'), Attribute(name='response_body', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='response_body'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='stripe_invoice_item_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stripe_invoice_item_id'), Attribute(name='token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_agent', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_agent'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__delitem__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__dict__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

mappingproxy({'__module__': 'kittycad.models.api_call_with_price', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'duration': typing.Union[kittycad.types.Unset, int], 'email': typing.Union[kittycad.types.Unset, str], 'endpoint': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'ip_address': typing.Union[kittycad.types.Unset, str], 'litterbox': typing.Union[kittycad.types.Unset, bool], 'method': typing.Union[kittycad.types.Unset, kittycad.models.method.Method], 'minutes': typing.Union[kittycad.types.Unset, int], 'origin': typing.Union[kittycad.types.Unset, str], 'price': typing.Union[kittycad.types.Unset, float], 'request_body': typing.Union[kittycad.types.Unset, str], 'request_query_params': typing.Union[kittycad.types.Unset, str], 'response_body': typing.Union[kittycad.types.Unset, str], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status_code': typing.Union[kittycad.types.Unset, int], 'stripe_invoice_item_id': typing.Union[kittycad.types.Unset, str], 'token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_agent': typing.Union[kittycad.types.Unset, str], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An API call with the price.\n\n    This is a join of the `ApiCall` and `ApiCallPrice` tables.', 'to_dict': <function ApiCallWithPrice.to_dict>, 'from_dict': <classmethod(<function ApiCallWithPrice.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ApiCallWithPrice.__getitem__>, '__setitem__': <function ApiCallWithPrice.__setitem__>, '__delitem__': <function ApiCallWithPrice.__delitem__>, '__contains__': <function ApiCallWithPrice.__contains__>, '__dict__': <attribute '__dict__' of 'ApiCallWithPrice' objects>, '__weakref__': <attribute '__weakref__' of 'ApiCallWithPrice' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='duration', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='duration'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='endpoint', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='endpoint'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='ip_address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ip_address'), Attribute(name='litterbox', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='litterbox'), Attribute(name='method', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.method.Method], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='method'), Attribute(name='minutes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='minutes'), Attribute(name='origin', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='origin'), Attribute(name='price', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='price'), Attribute(name='request_body', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_body'), Attribute(name='request_query_params', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_query_params'), Attribute(name='response_body', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='response_body'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='stripe_invoice_item_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stripe_invoice_item_id'), Attribute(name='token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_agent', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_agent'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ApiCallWithPrice.__repr__>, '__eq__': <function ApiCallWithPrice.__eq__>, '__ne__': <function ApiCallWithPrice.__ne__>, '__lt__': <function ApiCallWithPrice.__lt__>, '__le__': <function ApiCallWithPrice.__le__>, '__gt__': <function ApiCallWithPrice.__gt__>, '__ge__': <function ApiCallWithPrice.__ge__>, '__hash__': None, '__init__': <function ApiCallWithPrice.__init__>, '__match_args__': ('completed_at', 'created_at', 'duration', 'email', 'endpoint', 'id', 'ip_address', 'litterbox', 'method', 'minutes', 'origin', 'price', 'request_body', 'request_query_params', 'response_body', 'started_at', 'status_code', 'stripe_invoice_item_id', 'token', 'updated_at', 'user_agent', 'user_id')})

__eq__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__ge__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__getitem__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__gt__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__hash__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

__init__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

ApiCallWithPrice.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, duration=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, endpoint=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, ip_address=<kittycad.types.Unset object>, litterbox=False, method=<kittycad.types.Unset object>, minutes=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, price=<kittycad.types.Unset object>, request_body=<kittycad.types.Unset object>, request_query_params=<kittycad.types.Unset object>, response_body=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>, stripe_invoice_item_id=<kittycad.types.Unset object>, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_agent=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__lt__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__match_args__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

('completed_at', 'created_at', 'duration', 'email', 'endpoint', 'id', 'ip_address', 'litterbox', 'method', 'minutes', 'origin', 'price', 'request_body', 'request_query_params', 'response_body', 'started_at', 'status_code', 'stripe_invoice_item_id', 'token', 'updated_at', 'user_agent', 'user_id')

__module__ (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

__ne__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__repr__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

__setitem__() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

additional_keys (kittycad.models.api_call_with_price.ApiCallWithPrice property)

completed_at (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

created_at (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

duration (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

email (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

endpoint (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

from_dict() (kittycad.models.api_call_with_price.ApiCallWithPrice class method)

id (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

ip_address (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

litterbox (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

method (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

minutes (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

origin (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

price (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

request_body (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

response_body (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

started_at (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

status_code (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

to_dict() (kittycad.models.api_call_with_price.ApiCallWithPrice method)

token (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

updated_at (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

user_agent (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

user_id (kittycad.models.api_call_with_price.ApiCallWithPrice attribute)

__init__([completed_at, created_at, ...])

Method generated by attrs for class ApiCallWithPrice.

rtype

TypeVar(QP, bound= ApiCallWithPrice)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.api_call_with_price.ApiCallWithPrice.__init__>`\ \(\[completed\_at\, created\_at\, ...\]\)

completed_at

created_at

duration

email

endpoint

id

ip_address

litterbox

method

minutes

origin

price

request_body

request_query_params

response_body

started_at

status_code

stripe_invoice_item_id

token

updated_at

user_agent

user_id

ApiCallWithPriceResultsPage([items, next_page])

A single page of results

ApiCallWithPriceResultsPage (class in kittycad.models.api_call_with_price_results_page)

ApiCallWithPriceResultsPage(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

Method generated by attrs for class ApiCallWithPriceResultsPage.

ApiCallWithPriceResultsPage.ApiCallWithPrice (class in kittycad.models.api_call_with_price_results_page)

ApiCallWithPriceResultsPage.ApiCallWithPrice(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, duration=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, endpoint=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, ip_address=<kittycad.types.Unset object>, litterbox=False, method=<kittycad.types.Unset object>, minutes=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, price=<kittycad.types.Unset object>, request_body=<kittycad.types.Unset object>, request_query_params=<kittycad.types.Unset object>, response_body=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>, stripe_invoice_item_id=<kittycad.types.Unset object>, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_agent=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

ApiCallWithPriceResultsPage.ApiCallWithPrice.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, duration=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, endpoint=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, ip_address=<kittycad.types.Unset object>, litterbox=False, method=<kittycad.types.Unset object>, minutes=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, price=<kittycad.types.Unset object>, request_body=<kittycad.types.Unset object>, request_query_params=<kittycad.types.Unset object>, response_body=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>, stripe_invoice_item_id=<kittycad.types.Unset object>, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_agent=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

from_dict() (kittycad.models.api_call_with_price_results_page.ApiCallWithPriceResultsPage.ApiCallWithPrice class method)

{'additional_properties': typing.Dict[str, typing.Any], 'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_call_with_price.ApiCallWithPrice]], 'next_page': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_call_with_price.ApiCallWithPrice]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.api_call_with_price_results_page', '__annotations__': {'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_call_with_price.ApiCallWithPrice]], 'next_page': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A single page of results', 'ApiCallWithPrice': <class 'kittycad.models.api_call_with_price.ApiCallWithPrice'>, 'to_dict': <function ApiCallWithPriceResultsPage.to_dict>, 'from_dict': <classmethod(<function ApiCallWithPriceResultsPage.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ApiCallWithPriceResultsPage.__getitem__>, '__setitem__': <function ApiCallWithPriceResultsPage.__setitem__>, '__delitem__': <function ApiCallWithPriceResultsPage.__delitem__>, '__contains__': <function ApiCallWithPriceResultsPage.__contains__>, '__dict__': <attribute '__dict__' of 'ApiCallWithPriceResultsPage' objects>, '__weakref__': <attribute '__weakref__' of 'ApiCallWithPriceResultsPage' objects>, '__attrs_attrs__': (Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_call_with_price.ApiCallWithPrice]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ApiCallWithPriceResultsPage.__repr__>, '__eq__': <function ApiCallWithPriceResultsPage.__eq__>, '__ne__': <function ApiCallWithPriceResultsPage.__ne__>, '__lt__': <function ApiCallWithPriceResultsPage.__lt__>, '__le__': <function ApiCallWithPriceResultsPage.__le__>, '__gt__': <function ApiCallWithPriceResultsPage.__gt__>, '__ge__': <function ApiCallWithPriceResultsPage.__ge__>, '__hash__': None, '__init__': <function ApiCallWithPriceResultsPage.__init__>, '__match_args__': ('items', 'next_page')})

ApiCallWithPriceResultsPage.__init__(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

from_dict() (kittycad.models.api_call_with_price_results_page.ApiCallWithPriceResultsPage class method)

__init__([items, next_page])

rtype

TypeVar(KC, bound= ApiCallWithPriceResultsPage)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``KC``, bound= ApiCallWithPriceResultsPage)

items

next_page

ApiToken([created_at, id, is_valid, token, ...])

An API token.

:py:obj:`ApiToken <kittycad.models.api_token.ApiToken>`\ \(\[created\_at\, id\, is\_valid\, token\, ...\]\)

ApiToken(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, is_valid=False, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, is_valid=False, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

These are used to authenticate users with Bearer authentication.

{'additional_properties': typing.Dict[str, typing.Any], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'is_valid': typing.Union[kittycad.types.Unset, bool], 'token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='is_valid', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='is_valid'), Attribute(name='token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.api_token', '__annotations__': {'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'is_valid': typing.Union[kittycad.types.Unset, bool], 'token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An API token.\n\n    These are used to authenticate users with Bearer authentication.', 'to_dict': <function ApiToken.to_dict>, 'from_dict': <classmethod(<function ApiToken.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ApiToken.__getitem__>, '__setitem__': <function ApiToken.__setitem__>, '__delitem__': <function ApiToken.__delitem__>, '__contains__': <function ApiToken.__contains__>, '__dict__': <attribute '__dict__' of 'ApiToken' objects>, '__weakref__': <attribute '__weakref__' of 'ApiToken' objects>, '__attrs_attrs__': (Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='is_valid', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='is_valid'), Attribute(name='token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ApiToken.__repr__>, '__eq__': <function ApiToken.__eq__>, '__ne__': <function ApiToken.__ne__>, '__lt__': <function ApiToken.__lt__>, '__le__': <function ApiToken.__le__>, '__gt__': <function ApiToken.__gt__>, '__ge__': <function ApiToken.__ge__>, '__hash__': None, '__init__': <function ApiToken.__init__>, '__match_args__': ('created_at', 'id', 'is_valid', 'token', 'updated_at', 'user_id')})

ApiToken.__init__(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, is_valid=False, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

('created_at', 'id', 'is_valid', 'token', 'updated_at', 'user_id')

additional_properties (kittycad.models.api_token.ApiToken attribute)

__init__([created_at, id, is_valid, token, ...])

Method generated by attrs for class ApiToken.

rtype

TypeVar(HX, bound= ApiToken)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.api_token.ApiToken.__init__>`\ \(\[created\_at\, id\, is\_valid\, token\, ...\]\)

:py:obj:`to_dict <kittycad.models.api_token.ApiToken.to_dict>`\ \(\)

id

is_valid

token

user_id

ApiTokenResultsPage([items, next_page])

:py:obj:`ApiTokenResultsPage <kittycad.models.api_token_results_page.ApiTokenResultsPage>`\ \(\[items\, next\_page\]\)

ApiTokenResultsPage (class in kittycad.models.api_token_results_page)

ApiTokenResultsPage(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

ApiTokenResultsPage.ApiToken (class in kittycad.models.api_token_results_page)

ApiTokenResultsPage.ApiToken(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, is_valid=False, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

ApiTokenResultsPage.ApiToken.__init__(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, is_valid=False, token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

from_dict() (kittycad.models.api_token_results_page.ApiTokenResultsPage.ApiToken class method)

{'additional_properties': typing.Dict[str, typing.Any], 'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_token.ApiToken]], 'next_page': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_token.ApiToken]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.api_token_results_page.ApiTokenResultsPage attribute)

mappingproxy({'__module__': 'kittycad.models.api_token_results_page', '__annotations__': {'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_token.ApiToken]], 'next_page': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A single page of results', 'ApiToken': <class 'kittycad.models.api_token.ApiToken'>, 'to_dict': <function ApiTokenResultsPage.to_dict>, 'from_dict': <classmethod(<function ApiTokenResultsPage.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ApiTokenResultsPage.__getitem__>, '__setitem__': <function ApiTokenResultsPage.__setitem__>, '__delitem__': <function ApiTokenResultsPage.__delitem__>, '__contains__': <function ApiTokenResultsPage.__contains__>, '__dict__': <attribute '__dict__' of 'ApiTokenResultsPage' objects>, '__weakref__': <attribute '__weakref__' of 'ApiTokenResultsPage' objects>, '__attrs_attrs__': (Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.api_token.ApiToken]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ApiTokenResultsPage.__repr__>, '__eq__': <function ApiTokenResultsPage.__eq__>, '__ne__': <function ApiTokenResultsPage.__ne__>, '__lt__': <function ApiTokenResultsPage.__lt__>, '__le__': <function ApiTokenResultsPage.__le__>, '__gt__': <function ApiTokenResultsPage.__gt__>, '__ge__': <function ApiTokenResultsPage.__ge__>, '__hash__': None, '__init__': <function ApiTokenResultsPage.__init__>, '__match_args__': ('items', 'next_page')})

__eq__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__ge__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__gt__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__hash__ (kittycad.models.api_token_results_page.ApiTokenResultsPage attribute)

__init__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

ApiTokenResultsPage.__init__(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

__le__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__lt__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__ne__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

__repr__() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

from_dict() (kittycad.models.api_token_results_page.ApiTokenResultsPage class method)

items (kittycad.models.api_token_results_page.ApiTokenResultsPage attribute)

next_page (kittycad.models.api_token_results_page.ApiTokenResultsPage attribute)

to_dict() (kittycad.models.api_token_results_page.ApiTokenResultsPage method)

Method generated by attrs for class ApiTokenResultsPage.

rtype

TypeVar(LB, bound= ApiTokenResultsPage)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.api_token_results_page.ApiTokenResultsPage.__init__>`\ \(\[items\, next\_page\]\)

:py:class:`~typing.TypeVar`\(``LB``, bound= ApiTokenResultsPage)

AppClientInfo([url])

Information about a third party app client.

__annotations__ (kittycad.models.app_client_info.AppClientInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'url': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.app_client_info.AppClientInfo attribute)

(Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.app_client_info.AppClientInfo method)

__delitem__() (kittycad.models.app_client_info.AppClientInfo method)

__dict__ (kittycad.models.app_client_info.AppClientInfo attribute)

mappingproxy({'__module__': 'kittycad.models.app_client_info', '__annotations__': {'url': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Information about a third party app client.', 'to_dict': <function AppClientInfo.to_dict>, 'from_dict': <classmethod(<function AppClientInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AppClientInfo.__getitem__>, '__setitem__': <function AppClientInfo.__setitem__>, '__delitem__': <function AppClientInfo.__delitem__>, '__contains__': <function AppClientInfo.__contains__>, '__dict__': <attribute '__dict__' of 'AppClientInfo' objects>, '__weakref__': <attribute '__weakref__' of 'AppClientInfo' objects>, '__attrs_attrs__': (Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AppClientInfo.__repr__>, '__eq__': <function AppClientInfo.__eq__>, '__ne__': <function AppClientInfo.__ne__>, '__lt__': <function AppClientInfo.__lt__>, '__le__': <function AppClientInfo.__le__>, '__gt__': <function AppClientInfo.__gt__>, '__ge__': <function AppClientInfo.__ge__>, '__hash__': None, '__init__': <function AppClientInfo.__init__>, '__match_args__': ('url',)})

__getitem__() (kittycad.models.app_client_info.AppClientInfo method)

__hash__ (kittycad.models.app_client_info.AppClientInfo attribute)

__init__() (kittycad.models.app_client_info.AppClientInfo method)

__match_args__ (kittycad.models.app_client_info.AppClientInfo attribute)

__module__ (kittycad.models.app_client_info.AppClientInfo attribute)

__repr__() (kittycad.models.app_client_info.AppClientInfo method)

__setitem__() (kittycad.models.app_client_info.AppClientInfo method)

additional_keys (kittycad.models.app_client_info.AppClientInfo property)

additional_properties (kittycad.models.app_client_info.AppClientInfo attribute)

from_dict() (kittycad.models.app_client_info.AppClientInfo class method)

to_dict() (kittycad.models.app_client_info.AppClientInfo method)

__init__([url])

Method generated by attrs for class AppClientInfo.

rtype

TypeVar(NE, bound= AppClientInfo)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.app_client_info.AppClientInfo.to_dict>`\ \(\)

AsyncApiCall([completed_at, created_at, ...])

An async API call.

:py:obj:`AsyncApiCall <kittycad.models.async_api_call.AsyncApiCall>`\ \(\[completed\_at\, created\_at\, ...\]\)

AsyncApiCall(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, worker=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, worker=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.async_api_call.AsyncApiCall attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, typing.Any], 'output': typing.Union[kittycad.types.Unset, typing.Any], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': typing.Union[kittycad.types.Unset, kittycad.models.async_api_call_type.AsyncApiCallType], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'worker': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.async_api_call.AsyncApiCall attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.async_api_call_type.AsyncApiCallType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='worker', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='worker'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call.AsyncApiCall method)

__delitem__() (kittycad.models.async_api_call.AsyncApiCall method)

__dict__ (kittycad.models.async_api_call.AsyncApiCall attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, typing.Any], 'output': typing.Union[kittycad.types.Unset, typing.Any], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': typing.Union[kittycad.types.Unset, kittycad.models.async_api_call_type.AsyncApiCallType], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'worker': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An async API call.', 'to_dict': <function AsyncApiCall.to_dict>, 'from_dict': <classmethod(<function AsyncApiCall.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AsyncApiCall.__getitem__>, '__setitem__': <function AsyncApiCall.__setitem__>, '__delitem__': <function AsyncApiCall.__delitem__>, '__contains__': <function AsyncApiCall.__contains__>, '__dict__': <attribute '__dict__' of 'AsyncApiCall' objects>, '__weakref__': <attribute '__weakref__' of 'AsyncApiCall' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.async_api_call_type.AsyncApiCallType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='worker', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='worker'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AsyncApiCall.__repr__>, '__eq__': <function AsyncApiCall.__eq__>, '__ne__': <function AsyncApiCall.__ne__>, '__lt__': <function AsyncApiCall.__lt__>, '__le__': <function AsyncApiCall.__le__>, '__gt__': <function AsyncApiCall.__gt__>, '__ge__': <function AsyncApiCall.__ge__>, '__hash__': None, '__init__': <function AsyncApiCall.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'output', 'started_at', 'status', 'type', 'updated_at', 'user_id', 'worker')})

__getitem__() (kittycad.models.async_api_call.AsyncApiCall method)

__hash__ (kittycad.models.async_api_call.AsyncApiCall attribute)

AsyncApiCall.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, worker=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.async_api_call.AsyncApiCall attribute)

('completed_at', 'created_at', 'error', 'id', 'input', 'output', 'started_at', 'status', 'type', 'updated_at', 'user_id', 'worker')

__module__ (kittycad.models.async_api_call.AsyncApiCall attribute)

__setitem__() (kittycad.models.async_api_call.AsyncApiCall method)

additional_keys (kittycad.models.async_api_call.AsyncApiCall property)

additional_properties (kittycad.models.async_api_call.AsyncApiCall attribute)

completed_at (kittycad.models.async_api_call.AsyncApiCall attribute)

created_at (kittycad.models.async_api_call.AsyncApiCall attribute)

from_dict() (kittycad.models.async_api_call.AsyncApiCall class method)

started_at (kittycad.models.async_api_call.AsyncApiCall attribute)

updated_at (kittycad.models.async_api_call.AsyncApiCall attribute)

__init__([completed_at, created_at, error, ...])

Method generated by attrs for class AsyncApiCall.

rtype

TypeVar(TL, bound= AsyncApiCall)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call.AsyncApiCall.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`to_dict <kittycad.models.async_api_call.AsyncApiCall.to_dict>`\ \(\)

error

id

input

output

status

type

user_id

worker

FileCenterOfMass([center_of_mass, ...])

File center of mass.

FileConversion([completed_at, created_at, ...])

A file conversion.

FileDensity([completed_at, created_at, ...])

A file density.

FileMass([completed_at, created_at, error, ...])

A file mass.

FileSurfaceArea([completed_at, created_at, ...])

A file surface area.

FileVolume([completed_at, created_at, ...])

A file volume.

:py:obj:`FileCenterOfMass <kittycad.models.async_api_call_output.FileCenterOfMass>`\ \(\[center\_of\_mass\, ...\]\)

:py:obj:`FileConversion <kittycad.models.async_api_call_output.FileConversion>`\ \(\[completed\_at\, created\_at\, ...\]\)

:py:obj:`FileDensity <kittycad.models.async_api_call_output.FileDensity>`\ \(\[completed\_at\, created\_at\, ...\]\)

:py:obj:`FileMass <kittycad.models.async_api_call_output.FileMass>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`FileSurfaceArea <kittycad.models.async_api_call_output.FileSurfaceArea>`\ \(\[completed\_at\, created\_at\, ...\]\)

:py:obj:`FileVolume <kittycad.models.async_api_call_output.FileVolume>`\ \(\[completed\_at\, created\_at\, ...\]\)

FileCenterOfMass (class in kittycad.models.async_api_call_output)

FileCenterOfMass(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileCenterOfMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileCenterOfMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'center_of_mass': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='center_of_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center_of_mass'), Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileCenterOfMass', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__delitem__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__dict__ (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'center_of_mass': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'File center of mass.', 'to_dict': <function FileCenterOfMass.to_dict>, 'from_dict': <classmethod(<function FileCenterOfMass.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileCenterOfMass.__getitem__>, '__setitem__': <function FileCenterOfMass.__setitem__>, '__delitem__': <function FileCenterOfMass.__delitem__>, '__contains__': <function FileCenterOfMass.__contains__>, '__dict__': <attribute '__dict__' of 'FileCenterOfMass' objects>, '__weakref__': <attribute '__weakref__' of 'FileCenterOfMass' objects>, '__attrs_attrs__': (Attribute(name='center_of_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center_of_mass'), Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileCenterOfMass', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileCenterOfMass.__repr__>, '__eq__': <function FileCenterOfMass.__eq__>, '__ne__': <function FileCenterOfMass.__ne__>, '__lt__': <function FileCenterOfMass.__lt__>, '__le__': <function FileCenterOfMass.__le__>, '__gt__': <function FileCenterOfMass.__gt__>, '__ge__': <function FileCenterOfMass.__ge__>, '__hash__': None, '__init__': <function FileCenterOfMass.__init__>, '__match_args__': ('center_of_mass', 'completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')})

__eq__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__ge__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__getitem__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__gt__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__hash__ (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

__init__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

FileCenterOfMass.__init__(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileCenterOfMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__lt__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

('center_of_mass', 'completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')

__module__ (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

__ne__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__repr__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

__setitem__() (kittycad.models.async_api_call_output.FileCenterOfMass method)

completed_at (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

created_at (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

error (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

from_dict() (kittycad.models.async_api_call_output.FileCenterOfMass class method)

id (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

output_unit (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

src_format (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

started_at (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

status (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

to_dict() (kittycad.models.async_api_call_output.FileCenterOfMass method)

type (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

updated_at (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

user_id (kittycad.models.async_api_call_output.FileCenterOfMass attribute)

FileConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileConversion', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileConversion', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.async_api_call_output.FileConversion attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output': typing.Union[kittycad.types.Unset, str], 'output_format': typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], 'output_format_options': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'outputs': typing.Union[kittycad.types.Unset, typing.Any], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'src_format_options': typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.async_api_call_output.FileConversion attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format'), Attribute(name='output_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format_options'), Attribute(name='outputs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outputs'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='src_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format_options'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileConversion', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileConversion method)

__delitem__() (kittycad.models.async_api_call_output.FileConversion method)

__dict__ (kittycad.models.async_api_call_output.FileConversion attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output': typing.Union[kittycad.types.Unset, str], 'output_format': typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], 'output_format_options': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'outputs': typing.Union[kittycad.types.Unset, typing.Any], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'src_format_options': typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file conversion.', 'to_dict': <function FileConversion.to_dict>, 'from_dict': <classmethod(<function FileConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileConversion.__getitem__>, '__setitem__': <function FileConversion.__setitem__>, '__delitem__': <function FileConversion.__delitem__>, '__contains__': <function FileConversion.__contains__>, '__dict__': <attribute '__dict__' of 'FileConversion' objects>, '__weakref__': <attribute '__weakref__' of 'FileConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format'), Attribute(name='output_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format_options'), Attribute(name='outputs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outputs'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='src_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format_options'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileConversion', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileConversion.__repr__>, '__eq__': <function FileConversion.__eq__>, '__ne__': <function FileConversion.__ne__>, '__lt__': <function FileConversion.__lt__>, '__le__': <function FileConversion.__le__>, '__gt__': <function FileConversion.__gt__>, '__ge__': <function FileConversion.__ge__>, '__hash__': None, '__init__': <function FileConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output', 'output_format', 'output_format_options', 'outputs', 'src_format', 'src_format_options', 'started_at', 'status', 'type', 'updated_at', 'user_id')})

__eq__() (kittycad.models.async_api_call_output.FileConversion method)

__ge__() (kittycad.models.async_api_call_output.FileConversion method)

__getitem__() (kittycad.models.async_api_call_output.FileConversion method)

__gt__() (kittycad.models.async_api_call_output.FileConversion method)

__hash__ (kittycad.models.async_api_call_output.FileConversion attribute)

__init__() (kittycad.models.async_api_call_output.FileConversion method)

FileConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileConversion', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileConversion method)

__lt__() (kittycad.models.async_api_call_output.FileConversion method)

__match_args__ (kittycad.models.async_api_call_output.FileConversion attribute)

('completed_at', 'created_at', 'error', 'id', 'output', 'output_format', 'output_format_options', 'outputs', 'src_format', 'src_format_options', 'started_at', 'status', 'type', 'updated_at', 'user_id')

__module__ (kittycad.models.async_api_call_output.FileConversion attribute)

__ne__() (kittycad.models.async_api_call_output.FileConversion method)

__repr__() (kittycad.models.async_api_call_output.FileConversion method)

__setitem__() (kittycad.models.async_api_call_output.FileConversion method)

additional_keys (kittycad.models.async_api_call_output.FileConversion property)

completed_at (kittycad.models.async_api_call_output.FileConversion attribute)

created_at (kittycad.models.async_api_call_output.FileConversion attribute)

error (kittycad.models.async_api_call_output.FileConversion attribute)

from_dict() (kittycad.models.async_api_call_output.FileConversion class method)

id (kittycad.models.async_api_call_output.FileConversion attribute)

output (kittycad.models.async_api_call_output.FileConversion attribute)

output_format (kittycad.models.async_api_call_output.FileConversion attribute)

outputs (kittycad.models.async_api_call_output.FileConversion attribute)

src_format (kittycad.models.async_api_call_output.FileConversion attribute)

started_at (kittycad.models.async_api_call_output.FileConversion attribute)

status (kittycad.models.async_api_call_output.FileConversion attribute)

to_dict() (kittycad.models.async_api_call_output.FileConversion method)

type (kittycad.models.async_api_call_output.FileConversion attribute)

updated_at (kittycad.models.async_api_call_output.FileConversion attribute)

user_id (kittycad.models.async_api_call_output.FileConversion attribute)

FileDensity(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileDensity', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileDensity', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.async_api_call_output.FileDensity attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'density': typing.Union[kittycad.types.Unset, float], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'material_mass': typing.Union[kittycad.types.Unset, float], 'material_mass_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.async_api_call_output.FileDensity attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='density'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='material_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass'), Attribute(name='material_mass_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileDensity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileDensity method)

__delitem__() (kittycad.models.async_api_call_output.FileDensity method)

__dict__ (kittycad.models.async_api_call_output.FileDensity attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'density': typing.Union[kittycad.types.Unset, float], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'material_mass': typing.Union[kittycad.types.Unset, float], 'material_mass_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file density.', 'to_dict': <function FileDensity.to_dict>, 'from_dict': <classmethod(<function FileDensity.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileDensity.__getitem__>, '__setitem__': <function FileDensity.__setitem__>, '__delitem__': <function FileDensity.__delitem__>, '__contains__': <function FileDensity.__contains__>, '__dict__': <attribute '__dict__' of 'FileDensity' objects>, '__weakref__': <attribute '__weakref__' of 'FileDensity' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='density'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='material_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass'), Attribute(name='material_mass_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileDensity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileDensity.__repr__>, '__eq__': <function FileDensity.__eq__>, '__ne__': <function FileDensity.__ne__>, '__lt__': <function FileDensity.__lt__>, '__le__': <function FileDensity.__le__>, '__gt__': <function FileDensity.__gt__>, '__ge__': <function FileDensity.__ge__>, '__hash__': None, '__init__': <function FileDensity.__init__>, '__match_args__': ('completed_at', 'created_at', 'density', 'error', 'id', 'material_mass', 'material_mass_unit', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')})

__eq__() (kittycad.models.async_api_call_output.FileDensity method)

__ge__() (kittycad.models.async_api_call_output.FileDensity method)

__getitem__() (kittycad.models.async_api_call_output.FileDensity method)

__gt__() (kittycad.models.async_api_call_output.FileDensity method)

__hash__ (kittycad.models.async_api_call_output.FileDensity attribute)

__init__() (kittycad.models.async_api_call_output.FileDensity method)

FileDensity.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileDensity', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileDensity method)

__lt__() (kittycad.models.async_api_call_output.FileDensity method)

__match_args__ (kittycad.models.async_api_call_output.FileDensity attribute)

('completed_at', 'created_at', 'density', 'error', 'id', 'material_mass', 'material_mass_unit', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')

__module__ (kittycad.models.async_api_call_output.FileDensity attribute)

__ne__() (kittycad.models.async_api_call_output.FileDensity method)

__repr__() (kittycad.models.async_api_call_output.FileDensity method)

__setitem__() (kittycad.models.async_api_call_output.FileDensity method)

additional_keys (kittycad.models.async_api_call_output.FileDensity property)

completed_at (kittycad.models.async_api_call_output.FileDensity attribute)

created_at (kittycad.models.async_api_call_output.FileDensity attribute)

density (kittycad.models.async_api_call_output.FileDensity attribute)

error (kittycad.models.async_api_call_output.FileDensity attribute)

from_dict() (kittycad.models.async_api_call_output.FileDensity class method)

id (kittycad.models.async_api_call_output.FileDensity attribute)

material_mass (kittycad.models.async_api_call_output.FileDensity attribute)

material_mass_unit (kittycad.models.async_api_call_output.FileDensity attribute)

output_unit (kittycad.models.async_api_call_output.FileDensity attribute)

src_format (kittycad.models.async_api_call_output.FileDensity attribute)

started_at (kittycad.models.async_api_call_output.FileDensity attribute)

status (kittycad.models.async_api_call_output.FileDensity attribute)

to_dict() (kittycad.models.async_api_call_output.FileDensity method)

type (kittycad.models.async_api_call_output.FileDensity attribute)

updated_at (kittycad.models.async_api_call_output.FileDensity attribute)

user_id (kittycad.models.async_api_call_output.FileDensity attribute)

FileMass(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.async_api_call_output.FileMass attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'mass': typing.Union[kittycad.types.Unset, float], 'material_density': typing.Union[kittycad.types.Unset, float], 'material_density_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.async_api_call_output.FileMass attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mass'), Attribute(name='material_density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density'), Attribute(name='material_density_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileMass', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileMass method)

__delitem__() (kittycad.models.async_api_call_output.FileMass method)

__dict__ (kittycad.models.async_api_call_output.FileMass attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'mass': typing.Union[kittycad.types.Unset, float], 'material_density': typing.Union[kittycad.types.Unset, float], 'material_density_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file mass.', 'to_dict': <function FileMass.to_dict>, 'from_dict': <classmethod(<function FileMass.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileMass.__getitem__>, '__setitem__': <function FileMass.__setitem__>, '__delitem__': <function FileMass.__delitem__>, '__contains__': <function FileMass.__contains__>, '__dict__': <attribute '__dict__' of 'FileMass' objects>, '__weakref__': <attribute '__weakref__' of 'FileMass' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mass'), Attribute(name='material_density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density'), Attribute(name='material_density_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileMass', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileMass.__repr__>, '__eq__': <function FileMass.__eq__>, '__ne__': <function FileMass.__ne__>, '__lt__': <function FileMass.__lt__>, '__le__': <function FileMass.__le__>, '__gt__': <function FileMass.__gt__>, '__ge__': <function FileMass.__ge__>, '__hash__': None, '__init__': <function FileMass.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'mass', 'material_density', 'material_density_unit', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')})

__eq__() (kittycad.models.async_api_call_output.FileMass method)

__ge__() (kittycad.models.async_api_call_output.FileMass method)

__getitem__() (kittycad.models.async_api_call_output.FileMass method)

__gt__() (kittycad.models.async_api_call_output.FileMass method)

__hash__ (kittycad.models.async_api_call_output.FileMass attribute)

__init__() (kittycad.models.async_api_call_output.FileMass method)

FileMass.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileMass', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileMass method)

__lt__() (kittycad.models.async_api_call_output.FileMass method)

__match_args__ (kittycad.models.async_api_call_output.FileMass attribute)

('completed_at', 'created_at', 'error', 'id', 'mass', 'material_density', 'material_density_unit', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id')

__module__ (kittycad.models.async_api_call_output.FileMass attribute)

__ne__() (kittycad.models.async_api_call_output.FileMass method)

__repr__() (kittycad.models.async_api_call_output.FileMass method)

__setitem__() (kittycad.models.async_api_call_output.FileMass method)

additional_keys (kittycad.models.async_api_call_output.FileMass property)

additional_properties (kittycad.models.async_api_call_output.FileMass attribute)

completed_at (kittycad.models.async_api_call_output.FileMass attribute)

created_at (kittycad.models.async_api_call_output.FileMass attribute)

error (kittycad.models.async_api_call_output.FileMass attribute)

from_dict() (kittycad.models.async_api_call_output.FileMass class method)

material_density (kittycad.models.async_api_call_output.FileMass attribute)

material_density_unit (kittycad.models.async_api_call_output.FileMass attribute)

output_unit (kittycad.models.async_api_call_output.FileMass attribute)

src_format (kittycad.models.async_api_call_output.FileMass attribute)

started_at (kittycad.models.async_api_call_output.FileMass attribute)

status (kittycad.models.async_api_call_output.FileMass attribute)

to_dict() (kittycad.models.async_api_call_output.FileMass method)

updated_at (kittycad.models.async_api_call_output.FileMass attribute)

user_id (kittycad.models.async_api_call_output.FileMass attribute)

FileSurfaceArea (class in kittycad.models.async_api_call_output)

FileSurfaceArea(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, type='FileSurfaceArea', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, type='FileSurfaceArea', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'surface_area': typing.Union[kittycad.types.Unset, float], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='surface_area', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='surface_area'), Attribute(name='type', default='FileSurfaceArea', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__delitem__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__dict__ (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'surface_area': typing.Union[kittycad.types.Unset, float], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file surface area.', 'to_dict': <function FileSurfaceArea.to_dict>, 'from_dict': <classmethod(<function FileSurfaceArea.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileSurfaceArea.__getitem__>, '__setitem__': <function FileSurfaceArea.__setitem__>, '__delitem__': <function FileSurfaceArea.__delitem__>, '__contains__': <function FileSurfaceArea.__contains__>, '__dict__': <attribute '__dict__' of 'FileSurfaceArea' objects>, '__weakref__': <attribute '__weakref__' of 'FileSurfaceArea' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='surface_area', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='surface_area'), Attribute(name='type', default='FileSurfaceArea', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileSurfaceArea.__repr__>, '__eq__': <function FileSurfaceArea.__eq__>, '__ne__': <function FileSurfaceArea.__ne__>, '__lt__': <function FileSurfaceArea.__lt__>, '__le__': <function FileSurfaceArea.__le__>, '__gt__': <function FileSurfaceArea.__gt__>, '__ge__': <function FileSurfaceArea.__ge__>, '__hash__': None, '__init__': <function FileSurfaceArea.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'surface_area', 'type', 'updated_at', 'user_id')})

__eq__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__ge__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__getitem__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__gt__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__hash__ (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

__init__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

FileSurfaceArea.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, type='FileSurfaceArea', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__lt__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__match_args__ (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'surface_area', 'type', 'updated_at', 'user_id')

__module__ (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

__ne__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__repr__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

__setitem__() (kittycad.models.async_api_call_output.FileSurfaceArea method)

additional_keys (kittycad.models.async_api_call_output.FileSurfaceArea property)

completed_at (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

created_at (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

error (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

from_dict() (kittycad.models.async_api_call_output.FileSurfaceArea class method)

id (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

output_unit (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

src_format (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

started_at (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

status (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

surface_area (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

to_dict() (kittycad.models.async_api_call_output.FileSurfaceArea method)

type (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

updated_at (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

user_id (kittycad.models.async_api_call_output.FileSurfaceArea attribute)

FileVolume(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileVolume', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileVolume', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.async_api_call_output.FileVolume attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'volume': typing.Union[kittycad.types.Unset, float]}

__attrs_attrs__ (kittycad.models.async_api_call_output.FileVolume attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileVolume', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.async_api_call_output.FileVolume method)

__delitem__() (kittycad.models.async_api_call_output.FileVolume method)

__dict__ (kittycad.models.async_api_call_output.FileVolume attribute)

mappingproxy({'__module__': 'kittycad.models.async_api_call_output', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'type': <class 'str'>, 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'volume': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file volume.', 'to_dict': <function FileVolume.to_dict>, 'from_dict': <classmethod(<function FileVolume.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileVolume.__getitem__>, '__setitem__': <function FileVolume.__setitem__>, '__delitem__': <function FileVolume.__delitem__>, '__contains__': <function FileVolume.__contains__>, '__dict__': <attribute '__dict__' of 'FileVolume' objects>, '__weakref__': <attribute '__weakref__' of 'FileVolume' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='type', default='FileVolume', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileVolume.__repr__>, '__eq__': <function FileVolume.__eq__>, '__ne__': <function FileVolume.__ne__>, '__lt__': <function FileVolume.__lt__>, '__le__': <function FileVolume.__le__>, '__gt__': <function FileVolume.__gt__>, '__ge__': <function FileVolume.__ge__>, '__hash__': None, '__init__': <function FileVolume.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id', 'volume')})

__eq__() (kittycad.models.async_api_call_output.FileVolume method)

__ge__() (kittycad.models.async_api_call_output.FileVolume method)

__getitem__() (kittycad.models.async_api_call_output.FileVolume method)

__gt__() (kittycad.models.async_api_call_output.FileVolume method)

__hash__ (kittycad.models.async_api_call_output.FileVolume attribute)

__init__() (kittycad.models.async_api_call_output.FileVolume method)

FileVolume.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type='FileVolume', updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

__le__() (kittycad.models.async_api_call_output.FileVolume method)

__lt__() (kittycad.models.async_api_call_output.FileVolume method)

__match_args__ (kittycad.models.async_api_call_output.FileVolume attribute)

('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'type', 'updated_at', 'user_id', 'volume')

__module__ (kittycad.models.async_api_call_output.FileVolume attribute)

__ne__() (kittycad.models.async_api_call_output.FileVolume method)

__repr__() (kittycad.models.async_api_call_output.FileVolume method)

__setitem__() (kittycad.models.async_api_call_output.FileVolume method)

additional_keys (kittycad.models.async_api_call_output.FileVolume property)

completed_at (kittycad.models.async_api_call_output.FileVolume attribute)

created_at (kittycad.models.async_api_call_output.FileVolume attribute)

error (kittycad.models.async_api_call_output.FileVolume attribute)

from_dict() (kittycad.models.async_api_call_output.FileVolume class method)

output_unit (kittycad.models.async_api_call_output.FileVolume attribute)

src_format (kittycad.models.async_api_call_output.FileVolume attribute)

started_at (kittycad.models.async_api_call_output.FileVolume attribute)

status (kittycad.models.async_api_call_output.FileVolume attribute)

to_dict() (kittycad.models.async_api_call_output.FileVolume method)

type (kittycad.models.async_api_call_output.FileVolume attribute)

updated_at (kittycad.models.async_api_call_output.FileVolume attribute)

user_id (kittycad.models.async_api_call_output.FileVolume attribute)

volume (kittycad.models.async_api_call_output.FileVolume attribute)

__init__([center_of_mass, completed_at, ...])

Method generated by attrs for class FileCenterOfMass.

rtype

TypeVar(JV, bound= FileCenterOfMass)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileCenterOfMass.__init__>`\ \(\[center\_of\_mass\, completed\_at\, ...\]\)

center_of_mass

error

id

output_unit

src_format

status

type

user_id

Method generated by attrs for class FileConversion.

rtype

TypeVar(MN, bound= FileConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

error

id

output

output_format

output_format_options

outputs

src_format_options

status

type

user_id

Method generated by attrs for class FileDensity.

rtype

TypeVar(LE, bound= FileDensity)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileDensity.__init__>`\ \(\[completed\_at\, created\_at\, ...\]\)

density

error

id

material_mass

material_mass_unit

status

type

user_id

Method generated by attrs for class FileMass.

rtype

TypeVar(IO, bound= FileMass)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileMass.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`to_dict <kittycad.models.async_api_call_output.FileMass.to_dict>`\ \(\)

error

id

mass

material_density

material_density_unit

status

type

user_id

Method generated by attrs for class FileSurfaceArea.

rtype

TypeVar(OY, bound= FileSurfaceArea)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileSurfaceArea.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

error

id

status

surface_area

type

user_id

Method generated by attrs for class FileVolume.

rtype

TypeVar(FV, bound= FileVolume)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.async_api_call_output.FileVolume.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

error

id

status

type

user_id

volume

AsyncApiCallResultsPage([items, next_page])

AsyncApiCallResultsPage (class in kittycad.models.async_api_call_results_page)

AsyncApiCallResultsPage(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

AsyncApiCallResultsPage.AsyncApiCall (class in kittycad.models.async_api_call_results_page)

AsyncApiCallResultsPage.AsyncApiCall(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, worker=<kittycad.types.Unset object>)

AsyncApiCallResultsPage.AsyncApiCall.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, worker=<kittycad.types.Unset object>)

from_dict() (kittycad.models.async_api_call_results_page.AsyncApiCallResultsPage.AsyncApiCall class method)

{'additional_properties': typing.Dict[str, typing.Any], 'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.async_api_call.AsyncApiCall]], 'next_page': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.async_api_call.AsyncApiCall]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.async_api_call_results_page', '__annotations__': {'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.async_api_call.AsyncApiCall]], 'next_page': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A single page of results', 'AsyncApiCall': <class 'kittycad.models.async_api_call.AsyncApiCall'>, 'to_dict': <function AsyncApiCallResultsPage.to_dict>, 'from_dict': <classmethod(<function AsyncApiCallResultsPage.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AsyncApiCallResultsPage.__getitem__>, '__setitem__': <function AsyncApiCallResultsPage.__setitem__>, '__delitem__': <function AsyncApiCallResultsPage.__delitem__>, '__contains__': <function AsyncApiCallResultsPage.__contains__>, '__dict__': <attribute '__dict__' of 'AsyncApiCallResultsPage' objects>, '__weakref__': <attribute '__weakref__' of 'AsyncApiCallResultsPage' objects>, '__attrs_attrs__': (Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.async_api_call.AsyncApiCall]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AsyncApiCallResultsPage.__repr__>, '__eq__': <function AsyncApiCallResultsPage.__eq__>, '__ne__': <function AsyncApiCallResultsPage.__ne__>, '__lt__': <function AsyncApiCallResultsPage.__lt__>, '__le__': <function AsyncApiCallResultsPage.__le__>, '__gt__': <function AsyncApiCallResultsPage.__gt__>, '__ge__': <function AsyncApiCallResultsPage.__ge__>, '__hash__': None, '__init__': <function AsyncApiCallResultsPage.__init__>, '__match_args__': ('items', 'next_page')})

AsyncApiCallResultsPage.__init__(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

from_dict() (kittycad.models.async_api_call_results_page.AsyncApiCallResultsPage class method)

Method generated by attrs for class AsyncApiCallResultsPage.

rtype

TypeVar(HO, bound= AsyncApiCallResultsPage)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``HO``, bound= AsyncApiCallResultsPage)

AsyncApiCallType(value[, names, module, ...])

The type of async API call.

:py:obj:`AsyncApiCallType <kittycad.models.async_api_call_type.AsyncApiCallType>`\ \(value\[\, names\, module\, ...\]\)

AsyncApiCallType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

FILE_CONVERSION (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

FILE_DENSITY (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

docstring of kittycad.models.async_api_call_type.AsyncApiCallType.FILE_DENSITY

FILE_MASS (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

docstring of kittycad.models.async_api_call_type.AsyncApiCallType.FILE_MASS

FILE_VOLUME (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

docstring of kittycad.models.async_api_call_type.AsyncApiCallType.FILE_VOLUME

__add__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__annotations__ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

__contains__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__dict__ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.async_api_call_type', '__doc__': 'The type of async API call.', '__str__': <function AsyncApiCallType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['FILE_CONVERSION', 'FILE_VOLUME', 'FILE_CENTER_OF_MASS', 'FILE_MASS', 'FILE_DENSITY', 'FILE_SURFACE_AREA'], '_member_map_': {'FILE_CONVERSION': <AsyncApiCallType.FILE_CONVERSION: 'FileConversion'>, 'FILE_VOLUME': <AsyncApiCallType.FILE_VOLUME: 'FileVolume'>, 'FILE_CENTER_OF_MASS': <AsyncApiCallType.FILE_CENTER_OF_MASS: 'FileCenterOfMass'>, 'FILE_MASS': <AsyncApiCallType.FILE_MASS: 'FileMass'>, 'FILE_DENSITY': <AsyncApiCallType.FILE_DENSITY: 'FileDensity'>, 'FILE_SURFACE_AREA': <AsyncApiCallType.FILE_SURFACE_AREA: 'FileSurfaceArea'>}, '_value2member_map_': {'FileConversion': <AsyncApiCallType.FILE_CONVERSION: 'FileConversion'>, 'FileVolume': <AsyncApiCallType.FILE_VOLUME: 'FileVolume'>, 'FileCenterOfMass': <AsyncApiCallType.FILE_CENTER_OF_MASS: 'FileCenterOfMass'>, 'FileMass': <AsyncApiCallType.FILE_MASS: 'FileMass'>, 'FileDensity': <AsyncApiCallType.FILE_DENSITY: 'FileDensity'>, 'FileSurfaceArea': <AsyncApiCallType.FILE_SURFACE_AREA: 'FileSurfaceArea'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'AsyncApiCallType' objects>, '__weakref__': <attribute '__weakref__' of 'AsyncApiCallType' objects>, 'FILE_CONVERSION': <AsyncApiCallType.FILE_CONVERSION: 'FileConversion'>, 'FILE_VOLUME': <AsyncApiCallType.FILE_VOLUME: 'FileVolume'>, 'FILE_CENTER_OF_MASS': <AsyncApiCallType.FILE_CENTER_OF_MASS: 'FileCenterOfMass'>, 'FILE_MASS': <AsyncApiCallType.FILE_MASS: 'FileMass'>, 'FILE_DENSITY': <AsyncApiCallType.FILE_DENSITY: 'FileDensity'>, 'FILE_SURFACE_AREA': <AsyncApiCallType.FILE_SURFACE_AREA: 'FileSurfaceArea'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__eq__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__format__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__ge__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__getattribute__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__getitem__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__getnewargs__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__gt__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__hash__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__init__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__iter__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__le__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__len__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__lt__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__mod__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__module__ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

__mul__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__ne__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__new__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__reduce_ex__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__repr__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__rmod__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__rmul__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__sizeof__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

__str__() (kittycad.models.async_api_call_type.AsyncApiCallType method)

AsyncApiCallType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

{'FILE_CENTER_OF_MASS': AsyncApiCallType.FILE_CENTER_OF_MASS, 'FILE_CONVERSION': AsyncApiCallType.FILE_CONVERSION, 'FILE_DENSITY': AsyncApiCallType.FILE_DENSITY, 'FILE_MASS': AsyncApiCallType.FILE_MASS, 'FILE_SURFACE_AREA': AsyncApiCallType.FILE_SURFACE_AREA, 'FILE_VOLUME': AsyncApiCallType.FILE_VOLUME}

_member_names_ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

['FILE_CONVERSION', 'FILE_VOLUME', 'FILE_CENTER_OF_MASS', 'FILE_MASS', 'FILE_DENSITY', 'FILE_SURFACE_AREA']

_member_type_ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

_new_member_() (kittycad.models.async_api_call_type.AsyncApiCallType method)

_use_args_ (kittycad.models.async_api_call_type.AsyncApiCallType attribute)

{'FileCenterOfMass': AsyncApiCallType.FILE_CENTER_OF_MASS, 'FileConversion': AsyncApiCallType.FILE_CONVERSION, 'FileDensity': AsyncApiCallType.FILE_DENSITY, 'FileMass': AsyncApiCallType.FILE_MASS, 'FileSurfaceArea': AsyncApiCallType.FILE_SURFACE_AREA, 'FileVolume': AsyncApiCallType.FILE_VOLUME}

_value_repr_() (kittycad.models.async_api_call_type.AsyncApiCallType method)

capitalize() (kittycad.models.async_api_call_type.AsyncApiCallType method)

casefold() (kittycad.models.async_api_call_type.AsyncApiCallType method)

center() (kittycad.models.async_api_call_type.AsyncApiCallType method)

count() (kittycad.models.async_api_call_type.AsyncApiCallType method)

encode() (kittycad.models.async_api_call_type.AsyncApiCallType method)

endswith() (kittycad.models.async_api_call_type.AsyncApiCallType method)

expandtabs() (kittycad.models.async_api_call_type.AsyncApiCallType method)

find() (kittycad.models.async_api_call_type.AsyncApiCallType method)

format() (kittycad.models.async_api_call_type.AsyncApiCallType method)

format_map() (kittycad.models.async_api_call_type.AsyncApiCallType method)

index() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isalnum() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isalpha() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isascii() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isdecimal() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isdigit() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isidentifier() (kittycad.models.async_api_call_type.AsyncApiCallType method)

islower() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isnumeric() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isprintable() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isspace() (kittycad.models.async_api_call_type.AsyncApiCallType method)

istitle() (kittycad.models.async_api_call_type.AsyncApiCallType method)

isupper() (kittycad.models.async_api_call_type.AsyncApiCallType method)

join() (kittycad.models.async_api_call_type.AsyncApiCallType method)

ljust() (kittycad.models.async_api_call_type.AsyncApiCallType method)

lower() (kittycad.models.async_api_call_type.AsyncApiCallType method)

lstrip() (kittycad.models.async_api_call_type.AsyncApiCallType method)

maketrans() (kittycad.models.async_api_call_type.AsyncApiCallType static method)

partition() (kittycad.models.async_api_call_type.AsyncApiCallType method)

removeprefix() (kittycad.models.async_api_call_type.AsyncApiCallType method)

removesuffix() (kittycad.models.async_api_call_type.AsyncApiCallType method)

replace() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rfind() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rindex() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rjust() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rpartition() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rsplit() (kittycad.models.async_api_call_type.AsyncApiCallType method)

rstrip() (kittycad.models.async_api_call_type.AsyncApiCallType method)

split() (kittycad.models.async_api_call_type.AsyncApiCallType method)

splitlines() (kittycad.models.async_api_call_type.AsyncApiCallType method)

startswith() (kittycad.models.async_api_call_type.AsyncApiCallType method)

strip() (kittycad.models.async_api_call_type.AsyncApiCallType method)

swapcase() (kittycad.models.async_api_call_type.AsyncApiCallType method)

title() (kittycad.models.async_api_call_type.AsyncApiCallType method)

translate() (kittycad.models.async_api_call_type.AsyncApiCallType method)

upper() (kittycad.models.async_api_call_type.AsyncApiCallType method)

zfill() (kittycad.models.async_api_call_type.AsyncApiCallType method)

:py:obj:`__init__ <kittycad.models.async_api_call_type.AsyncApiCallType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.async_api_call_type.AsyncApiCallType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.async_api_call_type.AsyncApiCallType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.async_api_call_type.AsyncApiCallType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.async_api_call_type.AsyncApiCallType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.async_api_call_type.AsyncApiCallType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.async_api_call_type.AsyncApiCallType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.async_api_call_type.AsyncApiCallType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.async_api_call_type.AsyncApiCallType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.async_api_call_type.AsyncApiCallType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.async_api_call_type.AsyncApiCallType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.async_api_call_type.AsyncApiCallType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.async_api_call_type.AsyncApiCallType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.async_api_call_type.AsyncApiCallType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.async_api_call_type.AsyncApiCallType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.async_api_call_type.AsyncApiCallType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.async_api_call_type.AsyncApiCallType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.async_api_call_type.AsyncApiCallType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.async_api_call_type.AsyncApiCallType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.async_api_call_type.AsyncApiCallType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.async_api_call_type.AsyncApiCallType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.async_api_call_type.AsyncApiCallType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.async_api_call_type.AsyncApiCallType.zfill>`\ \(width\, \/\)

FILE_CONVERSION

# File volume.

FILE_VOLUME

# File center of mass.

FILE_CENTER_OF_MASS

# File mass.

FILE_MASS

# File density.

FILE_DENSITY

# File surface area.

FILE_SURFACE_AREA

Axis(value[, names, module, qualname, type, ...])

Co-ordinate axis specifier.

:py:obj:`Axis <kittycad.models.axis.Axis>`\ \(value\[\, names\, module\, qualname\, type\, ...\]\)

Axis(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.axis', '__doc__': 'Co-ordinate axis specifier.\n\n    See [cglearn.eu] for background reading.\n\n    [cglearn.eu]: https://cglearn.eu/pub/computer-graphics/introduction-to-geometry#material-coordinate-systems-1\n    ', '__str__': <function Axis.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['Y', 'Z'], '_member_map_': {'Y': <Axis.Y: 'y'>, 'Z': <Axis.Z: 'z'>}, '_value2member_map_': {'y': <Axis.Y: 'y'>, 'z': <Axis.Z: 'z'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Axis' objects>, '__weakref__': <attribute '__weakref__' of 'Axis' objects>, 'Y': <Axis.Y: 'y'>, 'Z': <Axis.Z: 'z'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

:py:obj:`__init__ <kittycad.models.axis.Axis.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.axis.Axis.capitalize>`\ \(\)

:py:obj:`center <kittycad.models.axis.Axis.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.axis.Axis.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.axis.Axis.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.axis.Axis.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`expandtabs <kittycad.models.axis.Axis.expandtabs>`\ \(\[tabsize\]\)

:py:obj:`find <kittycad.models.axis.Axis.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.axis.Axis.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`format_map <kittycad.models.axis.Axis.format_map>`\ \(mapping\)

:py:obj:`index <kittycad.models.axis.Axis.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isidentifier <kittycad.models.axis.Axis.isidentifier>`\ \(\)

:py:obj:`isprintable <kittycad.models.axis.Axis.isprintable>`\ \(\)

:py:obj:`join <kittycad.models.axis.Axis.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.axis.Axis.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lstrip <kittycad.models.axis.Axis.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.axis.Axis.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.axis.Axis.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.axis.Axis.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.axis.Axis.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.axis.Axis.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.axis.Axis.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.axis.Axis.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.axis.Axis.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.axis.Axis.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.axis.Axis.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.axis.Axis.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`splitlines <kittycad.models.axis.Axis.splitlines>`\ \(\[keepends\]\)

:py:obj:`startswith <kittycad.models.axis.Axis.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.axis.Axis.strip>`\ \(\[chars\]\)

:py:obj:`translate <kittycad.models.axis.Axis.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.axis.Axis.zfill>`\ \(width\, \/\)

AxisDirectionPair([axis, direction])

An [Axis] paired with a [Direction].

:py:obj:`AxisDirectionPair <kittycad.models.axis_direction_pair.AxisDirectionPair>`\ \(\[axis\, direction\]\)

AxisDirectionPair (class in kittycad.models.axis_direction_pair)

AxisDirectionPair(axis=<kittycad.types.Unset object>, direction=<kittycad.types.Unset object>)

(axis=<kittycad.types.Unset object>, direction=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'axis': typing.Union[kittycad.types.Unset, kittycad.models.axis.Axis], 'direction': typing.Union[kittycad.types.Unset, kittycad.models.direction.Direction]}

(Attribute(name='axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis.Axis], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='axis'), Attribute(name='direction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.direction.Direction], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='direction'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__delitem__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__dict__ (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

mappingproxy({'__module__': 'kittycad.models.axis_direction_pair', '__annotations__': {'axis': typing.Union[kittycad.types.Unset, kittycad.models.axis.Axis], 'direction': typing.Union[kittycad.types.Unset, kittycad.models.direction.Direction], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An [`Axis`] paired with a [`Direction`].', 'to_dict': <function AxisDirectionPair.to_dict>, 'from_dict': <classmethod(<function AxisDirectionPair.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function AxisDirectionPair.__getitem__>, '__setitem__': <function AxisDirectionPair.__setitem__>, '__delitem__': <function AxisDirectionPair.__delitem__>, '__contains__': <function AxisDirectionPair.__contains__>, '__dict__': <attribute '__dict__' of 'AxisDirectionPair' objects>, '__weakref__': <attribute '__weakref__' of 'AxisDirectionPair' objects>, '__attrs_attrs__': (Attribute(name='axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis.Axis], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='axis'), Attribute(name='direction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.direction.Direction], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='direction'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function AxisDirectionPair.__repr__>, '__eq__': <function AxisDirectionPair.__eq__>, '__ne__': <function AxisDirectionPair.__ne__>, '__lt__': <function AxisDirectionPair.__lt__>, '__le__': <function AxisDirectionPair.__le__>, '__gt__': <function AxisDirectionPair.__gt__>, '__ge__': <function AxisDirectionPair.__ge__>, '__hash__': None, '__init__': <function AxisDirectionPair.__init__>, '__match_args__': ('axis', 'direction')})

__eq__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__ge__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__getitem__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__gt__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__hash__ (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

__init__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

AxisDirectionPair.__init__(axis=<kittycad.types.Unset object>, direction=<kittycad.types.Unset object>)

__le__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__lt__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__match_args__ (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

__module__ (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

__ne__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__repr__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__setitem__() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

additional_keys (kittycad.models.axis_direction_pair.AxisDirectionPair property)

axis (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

direction (kittycad.models.axis_direction_pair.AxisDirectionPair attribute)

from_dict() (kittycad.models.axis_direction_pair.AxisDirectionPair class method)

to_dict() (kittycad.models.axis_direction_pair.AxisDirectionPair method)

__init__([axis, direction])

Method generated by attrs for class AxisDirectionPair.

rtype

TypeVar(TM, bound= AxisDirectionPair)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.axis_direction_pair.AxisDirectionPair.__init__>`\ \(\[axis\, direction\]\)

axis

direction

BillingInfo([address, name, phone])

The billing information for payments.

:py:obj:`BillingInfo <kittycad.models.billing_info.BillingInfo>`\ \(\[address\, name\, phone\]\)

BillingInfo(address=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

(address=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.billing_info.BillingInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'address': typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.billing_info.BillingInfo attribute)

(Attribute(name='address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.billing_info.BillingInfo method)

mappingproxy({'__module__': 'kittycad.models.billing_info', '__annotations__': {'address': typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The billing information for payments.', 'to_dict': <function BillingInfo.to_dict>, 'from_dict': <classmethod(<function BillingInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function BillingInfo.__getitem__>, '__setitem__': <function BillingInfo.__setitem__>, '__delitem__': <function BillingInfo.__delitem__>, '__contains__': <function BillingInfo.__contains__>, '__dict__': <attribute '__dict__' of 'BillingInfo' objects>, '__weakref__': <attribute '__weakref__' of 'BillingInfo' objects>, '__attrs_attrs__': (Attribute(name='address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function BillingInfo.__repr__>, '__eq__': <function BillingInfo.__eq__>, '__ne__': <function BillingInfo.__ne__>, '__lt__': <function BillingInfo.__lt__>, '__le__': <function BillingInfo.__le__>, '__gt__': <function BillingInfo.__gt__>, '__ge__': <function BillingInfo.__ge__>, '__hash__': None, '__init__': <function BillingInfo.__init__>, '__match_args__': ('address', 'name', 'phone')})

BillingInfo.__init__(address=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.billing_info.BillingInfo attribute)

additional_keys (kittycad.models.billing_info.BillingInfo property)

additional_properties (kittycad.models.billing_info.BillingInfo attribute)

from_dict() (kittycad.models.billing_info.BillingInfo class method)

__init__([address, name, phone])

Method generated by attrs for class BillingInfo.

rtype

TypeVar(BS, bound= BillingInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.billing_info.BillingInfo.__init__>`\ \(\[address\, name\, phone\]\)

:py:obj:`to_dict <kittycad.models.billing_info.BillingInfo.to_dict>`\ \(\)

address

name

phone

__annotations__ (kittycad.models.cache_metadata.CacheMetadata attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'ok': typing.Union[kittycad.types.Unset, bool]}

__attrs_attrs__ (kittycad.models.cache_metadata.CacheMetadata attribute)

(Attribute(name='ok', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ok'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.cache_metadata.CacheMetadata method)

__delitem__() (kittycad.models.cache_metadata.CacheMetadata method)

__dict__ (kittycad.models.cache_metadata.CacheMetadata attribute)

mappingproxy({'__module__': 'kittycad.models.cache_metadata', '__annotations__': {'ok': typing.Union[kittycad.types.Unset, bool], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our cache.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function CacheMetadata.to_dict>, 'from_dict': <classmethod(<function CacheMetadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function CacheMetadata.__getitem__>, '__setitem__': <function CacheMetadata.__setitem__>, '__delitem__': <function CacheMetadata.__delitem__>, '__contains__': <function CacheMetadata.__contains__>, '__dict__': <attribute '__dict__' of 'CacheMetadata' objects>, '__weakref__': <attribute '__weakref__' of 'CacheMetadata' objects>, '__attrs_attrs__': (Attribute(name='ok', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ok'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function CacheMetadata.__repr__>, '__eq__': <function CacheMetadata.__eq__>, '__ne__': <function CacheMetadata.__ne__>, '__lt__': <function CacheMetadata.__lt__>, '__le__': <function CacheMetadata.__le__>, '__gt__': <function CacheMetadata.__gt__>, '__ge__': <function CacheMetadata.__ge__>, '__hash__': None, '__init__': <function CacheMetadata.__init__>, '__match_args__': ('ok',)})

__getitem__() (kittycad.models.cache_metadata.CacheMetadata method)

__hash__ (kittycad.models.cache_metadata.CacheMetadata attribute)

__init__() (kittycad.models.cache_metadata.CacheMetadata method)

__match_args__ (kittycad.models.cache_metadata.CacheMetadata attribute)

__module__ (kittycad.models.cache_metadata.CacheMetadata attribute)

__repr__() (kittycad.models.cache_metadata.CacheMetadata method)

__setitem__() (kittycad.models.cache_metadata.CacheMetadata method)

additional_keys (kittycad.models.cache_metadata.CacheMetadata property)

additional_properties (kittycad.models.cache_metadata.CacheMetadata attribute)

from_dict() (kittycad.models.cache_metadata.CacheMetadata class method)

__init__([ok])

Method generated by attrs for class CacheMetadata.

rtype

TypeVar(AH, bound= CacheMetadata)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.cache_metadata.CacheMetadata.to_dict>`\ \(\)

CameraDragInteractionType(value[, names, ...])

The type of camera drag interaction.

:py:obj:`CameraDragInteractionType <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType>`\ \(value\[\, names\, ...\]\)

CameraDragInteractionType (class in kittycad.models.camera_drag_interaction_type)

CameraDragInteractionType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

# Camera zoom (increase or decrease distance to reference point center)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.camera_drag_interaction_type', '__doc__': 'The type of camera drag interaction.', '__str__': <function CameraDragInteractionType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['PAN', 'ROTATE', 'ZOOM'], '_member_map_': {'PAN': <CameraDragInteractionType.PAN: 'pan'>, 'ROTATE': <CameraDragInteractionType.ROTATE: 'rotate'>, 'ZOOM': <CameraDragInteractionType.ZOOM: 'zoom'>}, '_value2member_map_': {'pan': <CameraDragInteractionType.PAN: 'pan'>, 'rotate': <CameraDragInteractionType.ROTATE: 'rotate'>, 'zoom': <CameraDragInteractionType.ZOOM: 'zoom'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'CameraDragInteractionType' objects>, '__weakref__': <attribute '__weakref__' of 'CameraDragInteractionType' objects>, 'PAN': <CameraDragInteractionType.PAN: 'pan'>, 'ROTATE': <CameraDragInteractionType.ROTATE: 'rotate'>, 'ZOOM': <CameraDragInteractionType.ZOOM: 'zoom'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

CameraDragInteractionType._generate_next_value_(start, count, last_values)

{'PAN': CameraDragInteractionType.PAN, 'ROTATE': CameraDragInteractionType.ROTATE, 'ZOOM': CameraDragInteractionType.ZOOM}

{'pan': CameraDragInteractionType.PAN, 'rotate': CameraDragInteractionType.ROTATE, 'zoom': CameraDragInteractionType.ZOOM}

CameraDragInteractionType.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.camera_drag_interaction_type.CameraDragInteractionType static method)

CameraDragInteractionType.startswith(prefix[, start[, end]]) -> bool

:py:obj:`count <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`endswith <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`index <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.partition>`\ \(sep\, \/\)

:py:obj:`replace <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.camera_drag_interaction_type.CameraDragInteractionType.zfill>`\ \(width\, \/\)

PAN

# Camera rotate (revolve/orbit)

ROTATE

ZOOM

CardDetails([brand, checks, country, ...])

The card details of a payment method.

:py:obj:`CardDetails <kittycad.models.card_details.CardDetails>`\ \(\[brand\, checks\, country\, ...\]\)

CardDetails(brand=<kittycad.types.Unset object>, checks=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, exp_month=<kittycad.types.Unset object>, exp_year=<kittycad.types.Unset object>, fingerprint=<kittycad.types.Unset object>, funding=<kittycad.types.Unset object>, last4=<kittycad.types.Unset object>)

(brand=<kittycad.types.Unset object>, checks=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, exp_month=<kittycad.types.Unset object>, exp_year=<kittycad.types.Unset object>, fingerprint=<kittycad.types.Unset object>, funding=<kittycad.types.Unset object>, last4=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.card_details.CardDetails attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'brand': typing.Union[kittycad.types.Unset, str], 'checks': typing.Union[kittycad.types.Unset, kittycad.models.payment_method_card_checks.PaymentMethodCardChecks], 'country': typing.Union[kittycad.types.Unset, str], 'exp_month': typing.Union[kittycad.types.Unset, int], 'exp_year': typing.Union[kittycad.types.Unset, int], 'fingerprint': typing.Union[kittycad.types.Unset, str], 'funding': typing.Union[kittycad.types.Unset, str], 'last4': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.card_details.CardDetails attribute)

(Attribute(name='brand', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='brand'), Attribute(name='checks', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.payment_method_card_checks.PaymentMethodCardChecks], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='checks'), Attribute(name='country', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='country'), Attribute(name='exp_month', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='exp_month'), Attribute(name='exp_year', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='exp_year'), Attribute(name='fingerprint', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fingerprint'), Attribute(name='funding', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='funding'), Attribute(name='last4', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last4'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.card_details.CardDetails method)

mappingproxy({'__module__': 'kittycad.models.card_details', '__annotations__': {'brand': typing.Union[kittycad.types.Unset, str], 'checks': typing.Union[kittycad.types.Unset, kittycad.models.payment_method_card_checks.PaymentMethodCardChecks], 'country': typing.Union[kittycad.types.Unset, str], 'exp_month': typing.Union[kittycad.types.Unset, int], 'exp_year': typing.Union[kittycad.types.Unset, int], 'fingerprint': typing.Union[kittycad.types.Unset, str], 'funding': typing.Union[kittycad.types.Unset, str], 'last4': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The card details of a payment method.', 'to_dict': <function CardDetails.to_dict>, 'from_dict': <classmethod(<function CardDetails.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function CardDetails.__getitem__>, '__setitem__': <function CardDetails.__setitem__>, '__delitem__': <function CardDetails.__delitem__>, '__contains__': <function CardDetails.__contains__>, '__dict__': <attribute '__dict__' of 'CardDetails' objects>, '__weakref__': <attribute '__weakref__' of 'CardDetails' objects>, '__attrs_attrs__': (Attribute(name='brand', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='brand'), Attribute(name='checks', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.payment_method_card_checks.PaymentMethodCardChecks], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='checks'), Attribute(name='country', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='country'), Attribute(name='exp_month', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='exp_month'), Attribute(name='exp_year', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='exp_year'), Attribute(name='fingerprint', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fingerprint'), Attribute(name='funding', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='funding'), Attribute(name='last4', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last4'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function CardDetails.__repr__>, '__eq__': <function CardDetails.__eq__>, '__ne__': <function CardDetails.__ne__>, '__lt__': <function CardDetails.__lt__>, '__le__': <function CardDetails.__le__>, '__gt__': <function CardDetails.__gt__>, '__ge__': <function CardDetails.__ge__>, '__hash__': None, '__init__': <function CardDetails.__init__>, '__match_args__': ('brand', 'checks', 'country', 'exp_month', 'exp_year', 'fingerprint', 'funding', 'last4')})

CardDetails.__init__(brand=<kittycad.types.Unset object>, checks=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, exp_month=<kittycad.types.Unset object>, exp_year=<kittycad.types.Unset object>, fingerprint=<kittycad.types.Unset object>, funding=<kittycad.types.Unset object>, last4=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.card_details.CardDetails attribute)

('brand', 'checks', 'country', 'exp_month', 'exp_year', 'fingerprint', 'funding', 'last4')

additional_keys (kittycad.models.card_details.CardDetails property)

additional_properties (kittycad.models.card_details.CardDetails attribute)

fingerprint (kittycad.models.card_details.CardDetails attribute)

from_dict() (kittycad.models.card_details.CardDetails class method)

__init__([brand, checks, country, ...])

Method generated by attrs for class CardDetails.

rtype

TypeVar(EG, bound= CardDetails)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.card_details.CardDetails.__init__>`\ \(\[brand\, checks\, country\, ...\]\)

:py:obj:`to_dict <kittycad.models.card_details.CardDetails.to_dict>`\ \(\)

brand

checks

country

exp_month

exp_year

fingerprint

funding

last4

Cluster([addr, auth_timeout, cluster_port, ...])

Cluster information.

:py:obj:`Cluster <kittycad.models.cluster.Cluster>`\ \(\[addr\, auth\_timeout\, cluster\_port\, ...\]\)

Cluster(addr=<kittycad.types.Unset object>, auth_timeout=<kittycad.types.Unset object>, cluster_port=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, urls=<kittycad.types.Unset object>)

(addr=<kittycad.types.Unset object>, auth_timeout=<kittycad.types.Unset object>, cluster_port=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, urls=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'addr': typing.Union[kittycad.types.Unset, str], 'auth_timeout': typing.Union[kittycad.types.Unset, int], 'cluster_port': typing.Union[kittycad.types.Unset, int], 'name': typing.Union[kittycad.types.Unset, str], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'urls': typing.Union[kittycad.types.Unset, typing.List[str]]}

(Attribute(name='addr', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='addr'), Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='cluster_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_port'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='urls', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='urls'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.cluster', '__annotations__': {'addr': typing.Union[kittycad.types.Unset, str], 'auth_timeout': typing.Union[kittycad.types.Unset, int], 'cluster_port': typing.Union[kittycad.types.Unset, int], 'name': typing.Union[kittycad.types.Unset, str], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'urls': typing.Union[kittycad.types.Unset, typing.List[str]], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Cluster information.', 'to_dict': <function Cluster.to_dict>, 'from_dict': <classmethod(<function Cluster.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Cluster.__getitem__>, '__setitem__': <function Cluster.__setitem__>, '__delitem__': <function Cluster.__delitem__>, '__contains__': <function Cluster.__contains__>, '__dict__': <attribute '__dict__' of 'Cluster' objects>, '__weakref__': <attribute '__weakref__' of 'Cluster' objects>, '__attrs_attrs__': (Attribute(name='addr', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='addr'), Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='cluster_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_port'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='urls', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='urls'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Cluster.__repr__>, '__eq__': <function Cluster.__eq__>, '__ne__': <function Cluster.__ne__>, '__lt__': <function Cluster.__lt__>, '__le__': <function Cluster.__le__>, '__gt__': <function Cluster.__gt__>, '__ge__': <function Cluster.__ge__>, '__hash__': None, '__init__': <function Cluster.__init__>, '__match_args__': ('addr', 'auth_timeout', 'cluster_port', 'name', 'tls_timeout', 'urls')})

Cluster.__init__(addr=<kittycad.types.Unset object>, auth_timeout=<kittycad.types.Unset object>, cluster_port=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, urls=<kittycad.types.Unset object>)

('addr', 'auth_timeout', 'cluster_port', 'name', 'tls_timeout', 'urls')

additional_properties (kittycad.models.cluster.Cluster attribute)

__init__([addr, auth_timeout, cluster_port, ...])

Method generated by attrs for class Cluster.

rtype

TypeVar(JR, bound= Cluster)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.cluster.Cluster.__init__>`\ \(\[addr\, auth\_timeout\, cluster\_port\, ...\]\)

:py:obj:`from_dict <kittycad.models.cluster.Cluster.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.cluster.Cluster.to_dict>`\ \(\)

addr

auth_timeout

cluster_port

name

tls_timeout

urls

CodeLanguage(value[, names, module, ...])

The language code is written in.

:py:obj:`CodeLanguage <kittycad.models.code_language.CodeLanguage>`\ \(value\[\, names\, module\, ...\]\)

CodeLanguage(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.code_language.CodeLanguage attribute)

__contains__() (kittycad.models.code_language.CodeLanguage method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.code_language', '__doc__': 'The language code is written in.', '__str__': <function CodeLanguage.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['GO', 'PYTHON', 'NODE'], '_member_map_': {'GO': <CodeLanguage.GO: 'go'>, 'PYTHON': <CodeLanguage.PYTHON: 'python'>, 'NODE': <CodeLanguage.NODE: 'node'>}, '_value2member_map_': {'go': <CodeLanguage.GO: 'go'>, 'python': <CodeLanguage.PYTHON: 'python'>, 'node': <CodeLanguage.NODE: 'node'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'CodeLanguage' objects>, '__weakref__': <attribute '__weakref__' of 'CodeLanguage' objects>, 'GO': <CodeLanguage.GO: 'go'>, 'PYTHON': <CodeLanguage.PYTHON: 'python'>, 'NODE': <CodeLanguage.NODE: 'node'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__format__() (kittycad.models.code_language.CodeLanguage method)

__getattribute__() (kittycad.models.code_language.CodeLanguage method)

__getitem__() (kittycad.models.code_language.CodeLanguage method)

__getnewargs__() (kittycad.models.code_language.CodeLanguage method)

__module__ (kittycad.models.code_language.CodeLanguage attribute)

__reduce_ex__() (kittycad.models.code_language.CodeLanguage method)

__sizeof__() (kittycad.models.code_language.CodeLanguage method)

_generate_next_value_() (kittycad.models.code_language.CodeLanguage method)

_member_map_ (kittycad.models.code_language.CodeLanguage attribute)

{'GO': CodeLanguage.GO, 'NODE': CodeLanguage.NODE, 'PYTHON': CodeLanguage.PYTHON}

_member_names_ (kittycad.models.code_language.CodeLanguage attribute)

_member_type_ (kittycad.models.code_language.CodeLanguage attribute)

_new_member_() (kittycad.models.code_language.CodeLanguage method)

_unhashable_values_ (kittycad.models.code_language.CodeLanguage attribute)

_use_args_ (kittycad.models.code_language.CodeLanguage attribute)

_value2member_map_ (kittycad.models.code_language.CodeLanguage attribute)

{'go': CodeLanguage.GO, 'node': CodeLanguage.NODE, 'python': CodeLanguage.PYTHON}

_value_repr_() (kittycad.models.code_language.CodeLanguage method)

capitalize() (kittycad.models.code_language.CodeLanguage method)

expandtabs() (kittycad.models.code_language.CodeLanguage method)

format_map() (kittycad.models.code_language.CodeLanguage method)

isidentifier() (kittycad.models.code_language.CodeLanguage method)

isprintable() (kittycad.models.code_language.CodeLanguage method)

maketrans() (kittycad.models.code_language.CodeLanguage static method)

removeprefix() (kittycad.models.code_language.CodeLanguage method)

removesuffix() (kittycad.models.code_language.CodeLanguage method)

rpartition() (kittycad.models.code_language.CodeLanguage method)

splitlines() (kittycad.models.code_language.CodeLanguage method)

startswith() (kittycad.models.code_language.CodeLanguage method)

:py:obj:`__init__ <kittycad.models.code_language.CodeLanguage.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`casefold <kittycad.models.code_language.CodeLanguage.casefold>`\ \(\)

:py:obj:`center <kittycad.models.code_language.CodeLanguage.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.code_language.CodeLanguage.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.code_language.CodeLanguage.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.code_language.CodeLanguage.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.code_language.CodeLanguage.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.code_language.CodeLanguage.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.code_language.CodeLanguage.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.code_language.CodeLanguage.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.code_language.CodeLanguage.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.code_language.CodeLanguage.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.code_language.CodeLanguage.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.code_language.CodeLanguage.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.code_language.CodeLanguage.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.code_language.CodeLanguage.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.code_language.CodeLanguage.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.code_language.CodeLanguage.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.code_language.CodeLanguage.isupper>`\ \(\)

:py:obj:`join <kittycad.models.code_language.CodeLanguage.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.code_language.CodeLanguage.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.code_language.CodeLanguage.lower>`\ \(\)

:py:obj:`partition <kittycad.models.code_language.CodeLanguage.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.code_language.CodeLanguage.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.code_language.CodeLanguage.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.code_language.CodeLanguage.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.code_language.CodeLanguage.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.code_language.CodeLanguage.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.code_language.CodeLanguage.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.code_language.CodeLanguage.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.code_language.CodeLanguage.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.code_language.CodeLanguage.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.code_language.CodeLanguage.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`swapcase <kittycad.models.code_language.CodeLanguage.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.code_language.CodeLanguage.title>`\ \(\)

:py:obj:`translate <kittycad.models.code_language.CodeLanguage.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.code_language.CodeLanguage.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.code_language.CodeLanguage.zfill>`\ \(width\, \/\)

GO

# The python programming language.

PYTHON

# The node programming language.

NODE

CodeOutput([output_files, stderr, stdout])

Output of the code being executed.

:py:obj:`CodeOutput <kittycad.models.code_output.CodeOutput>`\ \(\[output\_files\, stderr\, stdout\]\)

CodeOutput(output_files=<kittycad.types.Unset object>, stderr=<kittycad.types.Unset object>, stdout=<kittycad.types.Unset object>)

(output_files=<kittycad.types.Unset object>, stderr=<kittycad.types.Unset object>, stdout=<kittycad.types.Unset object>)

CodeOutput.OutputFile(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'contents': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

(Attribute(name='contents', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='contents'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__delitem__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__dict__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

mappingproxy({'__module__': 'kittycad.models.output_file', '__annotations__': {'contents': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Output file contents.', 'to_dict': <function OutputFile.to_dict>, 'from_dict': <classmethod(<function OutputFile.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function OutputFile.__getitem__>, '__setitem__': <function OutputFile.__setitem__>, '__delitem__': <function OutputFile.__delitem__>, '__contains__': <function OutputFile.__contains__>, '__dict__': <attribute '__dict__' of 'OutputFile' objects>, '__weakref__': <attribute '__weakref__' of 'OutputFile' objects>, '__attrs_attrs__': (Attribute(name='contents', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='contents'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function OutputFile.__repr__>, '__eq__': <function OutputFile.__eq__>, '__ne__': <function OutputFile.__ne__>, '__lt__': <function OutputFile.__lt__>, '__le__': <function OutputFile.__le__>, '__gt__': <function OutputFile.__gt__>, '__ge__': <function OutputFile.__ge__>, '__hash__': None, '__init__': <function OutputFile.__init__>, '__match_args__': ('contents', 'name')})

__eq__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__ge__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__getitem__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__gt__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__hash__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

__init__() (kittycad.models.code_output.CodeOutput.OutputFile method)

CodeOutput.OutputFile.__init__(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__le__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__lt__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__match_args__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

__module__ (kittycad.models.code_output.CodeOutput.OutputFile attribute)

__ne__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__repr__() (kittycad.models.code_output.CodeOutput.OutputFile method)

__setitem__() (kittycad.models.code_output.CodeOutput.OutputFile method)

additional_keys (kittycad.models.code_output.CodeOutput.OutputFile property)

contents (kittycad.models.code_output.CodeOutput.OutputFile attribute)

from_dict() (kittycad.models.code_output.CodeOutput.OutputFile class method)

name (kittycad.models.code_output.CodeOutput.OutputFile attribute)

to_dict() (kittycad.models.code_output.CodeOutput.OutputFile method)

__annotations__ (kittycad.models.code_output.CodeOutput attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'output_files': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.output_file.OutputFile]], 'stderr': typing.Union[kittycad.types.Unset, str], 'stdout': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.code_output.CodeOutput attribute)

(Attribute(name='output_files', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.output_file.OutputFile]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_files'), Attribute(name='stderr', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stderr'), Attribute(name='stdout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stdout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.code_output', '__annotations__': {'output_files': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.output_file.OutputFile]], 'stderr': typing.Union[kittycad.types.Unset, str], 'stdout': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Output of the code being executed.', 'OutputFile': <class 'kittycad.models.output_file.OutputFile'>, 'to_dict': <function CodeOutput.to_dict>, 'from_dict': <classmethod(<function CodeOutput.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function CodeOutput.__getitem__>, '__setitem__': <function CodeOutput.__setitem__>, '__delitem__': <function CodeOutput.__delitem__>, '__contains__': <function CodeOutput.__contains__>, '__dict__': <attribute '__dict__' of 'CodeOutput' objects>, '__weakref__': <attribute '__weakref__' of 'CodeOutput' objects>, '__attrs_attrs__': (Attribute(name='output_files', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.output_file.OutputFile]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_files'), Attribute(name='stderr', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stderr'), Attribute(name='stdout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stdout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function CodeOutput.__repr__>, '__eq__': <function CodeOutput.__eq__>, '__ne__': <function CodeOutput.__ne__>, '__lt__': <function CodeOutput.__lt__>, '__le__': <function CodeOutput.__le__>, '__gt__': <function CodeOutput.__gt__>, '__ge__': <function CodeOutput.__ge__>, '__hash__': None, '__init__': <function CodeOutput.__init__>, '__match_args__': ('output_files', 'stderr', 'stdout')})

CodeOutput.__init__(output_files=<kittycad.types.Unset object>, stderr=<kittycad.types.Unset object>, stdout=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.code_output.CodeOutput attribute)

additional_keys (kittycad.models.code_output.CodeOutput property)

additional_properties (kittycad.models.code_output.CodeOutput attribute)

from_dict() (kittycad.models.code_output.CodeOutput class method)

__init__([output_files, stderr, stdout])

Method generated by attrs for class CodeOutput.

rtype

TypeVar(LY, bound= CodeOutput)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.code_output.CodeOutput.__init__>`\ \(\[output\_files\, stderr\, stdout\]\)

:py:obj:`to_dict <kittycad.models.code_output.CodeOutput.to_dict>`\ \(\)

output_files

stderr

stdout

:py:obj:`Color <kittycad.models.color.Color>`\ \(\[a\, b\, g\, r\]\)

Color(a=<kittycad.types.Unset object>, b=<kittycad.types.Unset object>, g=<kittycad.types.Unset object>, r=<kittycad.types.Unset object>)

(a=<kittycad.types.Unset object>, b=<kittycad.types.Unset object>, g=<kittycad.types.Unset object>, r=<kittycad.types.Unset object>)

{'a': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any], 'b': typing.Union[kittycad.types.Unset, float], 'g': typing.Union[kittycad.types.Unset, float], 'r': typing.Union[kittycad.types.Unset, float]}

(Attribute(name='a', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='a'), Attribute(name='b', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='b'), Attribute(name='g', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='g'), Attribute(name='r', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='r'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.color', '__annotations__': {'a': typing.Union[kittycad.types.Unset, float], 'b': typing.Union[kittycad.types.Unset, float], 'g': typing.Union[kittycad.types.Unset, float], 'r': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An RGBA color', 'to_dict': <function Color.to_dict>, 'from_dict': <classmethod(<function Color.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Color.__getitem__>, '__setitem__': <function Color.__setitem__>, '__delitem__': <function Color.__delitem__>, '__contains__': <function Color.__contains__>, '__dict__': <attribute '__dict__' of 'Color' objects>, '__weakref__': <attribute '__weakref__' of 'Color' objects>, '__attrs_attrs__': (Attribute(name='a', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='a'), Attribute(name='b', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='b'), Attribute(name='g', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='g'), Attribute(name='r', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='r'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Color.__repr__>, '__eq__': <function Color.__eq__>, '__ne__': <function Color.__ne__>, '__lt__': <function Color.__lt__>, '__le__': <function Color.__le__>, '__gt__': <function Color.__gt__>, '__ge__': <function Color.__ge__>, '__hash__': None, '__init__': <function Color.__init__>, '__match_args__': ('a', 'b', 'g', 'r')})

Color.__init__(a=<kittycad.types.Unset object>, b=<kittycad.types.Unset object>, g=<kittycad.types.Unset object>, r=<kittycad.types.Unset object>)

__init__([a, b, g, r])

Method generated by attrs for class Color.

rtype

TypeVar(HK, bound= Color)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.color.Color.__init__>`\ \(\[a\, b\, g\, r\]\)

:py:obj:`from_dict <kittycad.models.color.Color.from_dict>`\ \(src\_dict\)

a

b

g

r

Commit([expected, id])

Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as containerd, or runC.

:py:obj:`Commit <kittycad.models.commit.Commit>`\ \(\[expected\, id\]\)

Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as `containerd`, or `runC`.

Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as 

Commit(expected=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>)

(expected=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'expected': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='expected', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expected'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.commit', '__annotations__': {'expected': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as `containerd`, or `runC`.', 'to_dict': <function Commit.to_dict>, 'from_dict': <classmethod(<function Commit.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Commit.__getitem__>, '__setitem__': <function Commit.__setitem__>, '__delitem__': <function Commit.__delitem__>, '__contains__': <function Commit.__contains__>, '__dict__': <attribute '__dict__' of 'Commit' objects>, '__weakref__': <attribute '__weakref__' of 'Commit' objects>, '__attrs_attrs__': (Attribute(name='expected', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expected'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Commit.__repr__>, '__eq__': <function Commit.__eq__>, '__ne__': <function Commit.__ne__>, '__lt__': <function Commit.__lt__>, '__le__': <function Commit.__le__>, '__gt__': <function Commit.__gt__>, '__ge__': <function Commit.__ge__>, '__hash__': None, '__init__': <function Commit.__init__>, '__match_args__': ('expected', 'id')})

Commit.__init__(expected=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>)

__init__([expected, id])

Method generated by attrs for class Commit.

rtype

TypeVar(VR, bound= Commit)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.commit.Commit.__init__>`\ \(\[expected\, id\]\)

:py:obj:`from_dict <kittycad.models.commit.Commit.from_dict>`\ \(src\_dict\)

expected

id

Connection([auth_timeout, cluster, ...])

Metadata about a pub-sub connection.

:py:obj:`Connection <kittycad.models.connection.Connection>`\ \(\[auth\_timeout\, cluster\, ...\]\)

Connection(auth_timeout=<kittycad.types.Unset object>, cluster=<kittycad.types.Unset object>, config_load_time=<kittycad.types.Unset object>, connections=<kittycad.types.Unset object>, cores=<kittycad.types.Unset object>, cpu=<kittycad.types.Unset object>, gateway=<kittycad.types.Unset object>, git_commit=<kittycad.types.Unset object>, go=<kittycad.types.Unset object>, gomaxprocs=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, http_base_path=<kittycad.types.Unset object>, http_host=<kittycad.types.Unset object>, http_port=<kittycad.types.Unset object>, http_req_stats=<kittycad.types.Unset object>, https_port=<kittycad.types.Unset object>, in_bytes=<kittycad.types.Unset object>, in_msgs=<kittycad.types.Unset object>, jetstream=<kittycad.types.Unset object>, leaf=<kittycad.types.Unset object>, leafnodes=<kittycad.types.Unset object>, max_connections=<kittycad.types.Unset object>, max_control_line=<kittycad.types.Unset object>, max_payload=<kittycad.types.Unset object>, max_pending=<kittycad.types.Unset object>, mem=<kittycad.types.Unset object>, now=<kittycad.types.Unset object>, out_bytes=<kittycad.types.Unset object>, out_msgs=<kittycad.types.Unset object>, ping_interval=<kittycad.types.Unset object>, ping_max=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, proto=<kittycad.types.Unset object>, remotes=<kittycad.types.Unset object>, routes=<kittycad.types.Unset object>, server_id=<kittycad.types.Unset object>, server_name=<kittycad.types.Unset object>, slow_consumers=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>, subscriptions=<kittycad.types.Unset object>, system_account=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, total_connections=<kittycad.types.Unset object>, uptime=<kittycad.types.Unset object>, version=<kittycad.types.Unset object>, write_deadline=<kittycad.types.Unset object>)

(auth_timeout=<kittycad.types.Unset object>, cluster=<kittycad.types.Unset object>, config_load_time=<kittycad.types.Unset object>, connections=<kittycad.types.Unset object>, cores=<kittycad.types.Unset object>, cpu=<kittycad.types.Unset object>, gateway=<kittycad.types.Unset object>, git_commit=<kittycad.types.Unset object>, go=<kittycad.types.Unset object>, gomaxprocs=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, http_base_path=<kittycad.types.Unset object>, http_host=<kittycad.types.Unset object>, http_port=<kittycad.types.Unset object>, http_req_stats=<kittycad.types.Unset object>, https_port=<kittycad.types.Unset object>, in_bytes=<kittycad.types.Unset object>, in_msgs=<kittycad.types.Unset object>, jetstream=<kittycad.types.Unset object>, leaf=<kittycad.types.Unset object>, leafnodes=<kittycad.types.Unset object>, max_connections=<kittycad.types.Unset object>, max_control_line=<kittycad.types.Unset object>, max_payload=<kittycad.types.Unset object>, max_pending=<kittycad.types.Unset object>, mem=<kittycad.types.Unset object>, now=<kittycad.types.Unset object>, out_bytes=<kittycad.types.Unset object>, out_msgs=<kittycad.types.Unset object>, ping_interval=<kittycad.types.Unset object>, ping_max=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, proto=<kittycad.types.Unset object>, remotes=<kittycad.types.Unset object>, routes=<kittycad.types.Unset object>, server_id=<kittycad.types.Unset object>, server_name=<kittycad.types.Unset object>, slow_consumers=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>, subscriptions=<kittycad.types.Unset object>, system_account=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, total_connections=<kittycad.types.Unset object>, uptime=<kittycad.types.Unset object>, version=<kittycad.types.Unset object>, write_deadline=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.connection.Connection attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'auth_timeout': typing.Union[kittycad.types.Unset, int], 'cluster': typing.Union[kittycad.types.Unset, kittycad.models.cluster.Cluster], 'config_load_time': typing.Union[kittycad.types.Unset, datetime.datetime], 'connections': typing.Union[kittycad.types.Unset, int], 'cores': typing.Union[kittycad.types.Unset, int], 'cpu': typing.Union[kittycad.types.Unset, float], 'gateway': typing.Union[kittycad.types.Unset, kittycad.models.gateway.Gateway], 'git_commit': typing.Union[kittycad.types.Unset, str], 'go': typing.Union[kittycad.types.Unset, str], 'gomaxprocs': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'http_base_path': typing.Union[kittycad.types.Unset, str], 'http_host': typing.Union[kittycad.types.Unset, str], 'http_port': typing.Union[kittycad.types.Unset, int], 'http_req_stats': typing.Union[kittycad.types.Unset, typing.Any], 'https_port': typing.Union[kittycad.types.Unset, int], 'in_bytes': typing.Union[kittycad.types.Unset, int], 'in_msgs': typing.Union[kittycad.types.Unset, int], 'jetstream': typing.Union[kittycad.types.Unset, kittycad.models.jetstream.Jetstream], 'leaf': typing.Union[kittycad.types.Unset, kittycad.models.leaf_node.LeafNode], 'leafnodes': typing.Union[kittycad.types.Unset, int], 'max_connections': typing.Union[kittycad.types.Unset, int], 'max_control_line': typing.Union[kittycad.types.Unset, int], 'max_payload': typing.Union[kittycad.types.Unset, int], 'max_pending': typing.Union[kittycad.types.Unset, int], 'mem': typing.Union[kittycad.types.Unset, int], 'now': typing.Union[kittycad.types.Unset, datetime.datetime], 'out_bytes': typing.Union[kittycad.types.Unset, int], 'out_msgs': typing.Union[kittycad.types.Unset, int], 'ping_interval': typing.Union[kittycad.types.Unset, int], 'ping_max': typing.Union[kittycad.types.Unset, int], 'port': typing.Union[kittycad.types.Unset, int], 'proto': typing.Union[kittycad.types.Unset, int], 'remotes': typing.Union[kittycad.types.Unset, int], 'routes': typing.Union[kittycad.types.Unset, int], 'server_id': typing.Union[kittycad.types.Unset, str], 'server_name': typing.Union[kittycad.types.Unset, str], 'slow_consumers': typing.Union[kittycad.types.Unset, int], 'start': typing.Union[kittycad.types.Unset, datetime.datetime], 'subscriptions': typing.Union[kittycad.types.Unset, int], 'system_account': typing.Union[kittycad.types.Unset, str], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'total_connections': typing.Union[kittycad.types.Unset, int], 'uptime': typing.Union[kittycad.types.Unset, str], 'version': typing.Union[kittycad.types.Unset, str], 'write_deadline': typing.Union[kittycad.types.Unset, int]}

__attrs_attrs__ (kittycad.models.connection.Connection attribute)

(Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='cluster', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cluster.Cluster], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster'), Attribute(name='config_load_time', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='config_load_time'), Attribute(name='connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='connections'), Attribute(name='cores', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cores'), Attribute(name='cpu', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu'), Attribute(name='gateway', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.gateway.Gateway], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='gateway'), Attribute(name='git_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_commit'), Attribute(name='go', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='go'), Attribute(name='gomaxprocs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='gomaxprocs'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='http_base_path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_base_path'), Attribute(name='http_host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_host'), Attribute(name='http_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_port'), Attribute(name='http_req_stats', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_req_stats'), Attribute(name='https_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='https_port'), Attribute(name='in_bytes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='in_bytes'), Attribute(name='in_msgs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='in_msgs'), Attribute(name='jetstream', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream.Jetstream], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='jetstream'), Attribute(name='leaf', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.leaf_node.LeafNode], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leaf'), Attribute(name='leafnodes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leafnodes'), Attribute(name='max_connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_connections'), Attribute(name='max_control_line', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_control_line'), Attribute(name='max_payload', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_payload'), Attribute(name='max_pending', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_pending'), Attribute(name='mem', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mem'), Attribute(name='now', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='now'), Attribute(name='out_bytes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='out_bytes'), Attribute(name='out_msgs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='out_msgs'), Attribute(name='ping_interval', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ping_interval'), Attribute(name='ping_max', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ping_max'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='proto', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='proto'), Attribute(name='remotes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='remotes'), Attribute(name='routes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='routes'), Attribute(name='server_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_id'), Attribute(name='server_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_name'), Attribute(name='slow_consumers', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='slow_consumers'), Attribute(name='start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='start'), Attribute(name='subscriptions', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='subscriptions'), Attribute(name='system_account', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='system_account'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='total_connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total_connections'), Attribute(name='uptime', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='uptime'), Attribute(name='version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='version'), Attribute(name='write_deadline', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='write_deadline'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.connection', '__annotations__': {'auth_timeout': typing.Union[kittycad.types.Unset, int], 'cluster': typing.Union[kittycad.types.Unset, kittycad.models.cluster.Cluster], 'config_load_time': typing.Union[kittycad.types.Unset, datetime.datetime], 'connections': typing.Union[kittycad.types.Unset, int], 'cores': typing.Union[kittycad.types.Unset, int], 'cpu': typing.Union[kittycad.types.Unset, float], 'gateway': typing.Union[kittycad.types.Unset, kittycad.models.gateway.Gateway], 'git_commit': typing.Union[kittycad.types.Unset, str], 'go': typing.Union[kittycad.types.Unset, str], 'gomaxprocs': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'http_base_path': typing.Union[kittycad.types.Unset, str], 'http_host': typing.Union[kittycad.types.Unset, str], 'http_port': typing.Union[kittycad.types.Unset, int], 'http_req_stats': typing.Union[kittycad.types.Unset, typing.Any], 'https_port': typing.Union[kittycad.types.Unset, int], 'in_bytes': typing.Union[kittycad.types.Unset, int], 'in_msgs': typing.Union[kittycad.types.Unset, int], 'jetstream': typing.Union[kittycad.types.Unset, kittycad.models.jetstream.Jetstream], 'leaf': typing.Union[kittycad.types.Unset, kittycad.models.leaf_node.LeafNode], 'leafnodes': typing.Union[kittycad.types.Unset, int], 'max_connections': typing.Union[kittycad.types.Unset, int], 'max_control_line': typing.Union[kittycad.types.Unset, int], 'max_payload': typing.Union[kittycad.types.Unset, int], 'max_pending': typing.Union[kittycad.types.Unset, int], 'mem': typing.Union[kittycad.types.Unset, int], 'now': typing.Union[kittycad.types.Unset, datetime.datetime], 'out_bytes': typing.Union[kittycad.types.Unset, int], 'out_msgs': typing.Union[kittycad.types.Unset, int], 'ping_interval': typing.Union[kittycad.types.Unset, int], 'ping_max': typing.Union[kittycad.types.Unset, int], 'port': typing.Union[kittycad.types.Unset, int], 'proto': typing.Union[kittycad.types.Unset, int], 'remotes': typing.Union[kittycad.types.Unset, int], 'routes': typing.Union[kittycad.types.Unset, int], 'server_id': typing.Union[kittycad.types.Unset, str], 'server_name': typing.Union[kittycad.types.Unset, str], 'slow_consumers': typing.Union[kittycad.types.Unset, int], 'start': typing.Union[kittycad.types.Unset, datetime.datetime], 'subscriptions': typing.Union[kittycad.types.Unset, int], 'system_account': typing.Union[kittycad.types.Unset, str], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'total_connections': typing.Union[kittycad.types.Unset, int], 'uptime': typing.Union[kittycad.types.Unset, str], 'version': typing.Union[kittycad.types.Unset, str], 'write_deadline': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about a pub-sub connection.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function Connection.to_dict>, 'from_dict': <classmethod(<function Connection.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Connection.__getitem__>, '__setitem__': <function Connection.__setitem__>, '__delitem__': <function Connection.__delitem__>, '__contains__': <function Connection.__contains__>, '__dict__': <attribute '__dict__' of 'Connection' objects>, '__weakref__': <attribute '__weakref__' of 'Connection' objects>, '__attrs_attrs__': (Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='cluster', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cluster.Cluster], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster'), Attribute(name='config_load_time', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='config_load_time'), Attribute(name='connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='connections'), Attribute(name='cores', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cores'), Attribute(name='cpu', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu'), Attribute(name='gateway', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.gateway.Gateway], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='gateway'), Attribute(name='git_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_commit'), Attribute(name='go', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='go'), Attribute(name='gomaxprocs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='gomaxprocs'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='http_base_path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_base_path'), Attribute(name='http_host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_host'), Attribute(name='http_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_port'), Attribute(name='http_req_stats', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_req_stats'), Attribute(name='https_port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='https_port'), Attribute(name='in_bytes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='in_bytes'), Attribute(name='in_msgs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='in_msgs'), Attribute(name='jetstream', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream.Jetstream], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='jetstream'), Attribute(name='leaf', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.leaf_node.LeafNode], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leaf'), Attribute(name='leafnodes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leafnodes'), Attribute(name='max_connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_connections'), Attribute(name='max_control_line', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_control_line'), Attribute(name='max_payload', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_payload'), Attribute(name='max_pending', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_pending'), Attribute(name='mem', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mem'), Attribute(name='now', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='now'), Attribute(name='out_bytes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='out_bytes'), Attribute(name='out_msgs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='out_msgs'), Attribute(name='ping_interval', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ping_interval'), Attribute(name='ping_max', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ping_max'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='proto', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='proto'), Attribute(name='remotes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='remotes'), Attribute(name='routes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='routes'), Attribute(name='server_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_id'), Attribute(name='server_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_name'), Attribute(name='slow_consumers', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='slow_consumers'), Attribute(name='start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='start'), Attribute(name='subscriptions', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='subscriptions'), Attribute(name='system_account', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='system_account'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='total_connections', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total_connections'), Attribute(name='uptime', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='uptime'), Attribute(name='version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='version'), Attribute(name='write_deadline', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='write_deadline'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Connection.__repr__>, '__eq__': <function Connection.__eq__>, '__ne__': <function Connection.__ne__>, '__lt__': <function Connection.__lt__>, '__le__': <function Connection.__le__>, '__gt__': <function Connection.__gt__>, '__ge__': <function Connection.__ge__>, '__hash__': None, '__init__': <function Connection.__init__>, '__match_args__': ('auth_timeout', 'cluster', 'config_load_time', 'connections', 'cores', 'cpu', 'gateway', 'git_commit', 'go', 'gomaxprocs', 'host', 'http_base_path', 'http_host', 'http_port', 'http_req_stats', 'https_port', 'in_bytes', 'in_msgs', 'jetstream', 'leaf', 'leafnodes', 'max_connections', 'max_control_line', 'max_payload', 'max_pending', 'mem', 'now', 'out_bytes', 'out_msgs', 'ping_interval', 'ping_max', 'port', 'proto', 'remotes', 'routes', 'server_id', 'server_name', 'slow_consumers', 'start', 'subscriptions', 'system_account', 'tls_timeout', 'total_connections', 'uptime', 'version', 'write_deadline')})

Connection.__init__(auth_timeout=<kittycad.types.Unset object>, cluster=<kittycad.types.Unset object>, config_load_time=<kittycad.types.Unset object>, connections=<kittycad.types.Unset object>, cores=<kittycad.types.Unset object>, cpu=<kittycad.types.Unset object>, gateway=<kittycad.types.Unset object>, git_commit=<kittycad.types.Unset object>, go=<kittycad.types.Unset object>, gomaxprocs=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, http_base_path=<kittycad.types.Unset object>, http_host=<kittycad.types.Unset object>, http_port=<kittycad.types.Unset object>, http_req_stats=<kittycad.types.Unset object>, https_port=<kittycad.types.Unset object>, in_bytes=<kittycad.types.Unset object>, in_msgs=<kittycad.types.Unset object>, jetstream=<kittycad.types.Unset object>, leaf=<kittycad.types.Unset object>, leafnodes=<kittycad.types.Unset object>, max_connections=<kittycad.types.Unset object>, max_control_line=<kittycad.types.Unset object>, max_payload=<kittycad.types.Unset object>, max_pending=<kittycad.types.Unset object>, mem=<kittycad.types.Unset object>, now=<kittycad.types.Unset object>, out_bytes=<kittycad.types.Unset object>, out_msgs=<kittycad.types.Unset object>, ping_interval=<kittycad.types.Unset object>, ping_max=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, proto=<kittycad.types.Unset object>, remotes=<kittycad.types.Unset object>, routes=<kittycad.types.Unset object>, server_id=<kittycad.types.Unset object>, server_name=<kittycad.types.Unset object>, slow_consumers=<kittycad.types.Unset object>, start=<kittycad.types.Unset object>, subscriptions=<kittycad.types.Unset object>, system_account=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>, total_connections=<kittycad.types.Unset object>, uptime=<kittycad.types.Unset object>, version=<kittycad.types.Unset object>, write_deadline=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.connection.Connection attribute)

('auth_timeout', 'cluster', 'config_load_time', 'connections', 'cores', 'cpu', 'gateway', 'git_commit', 'go', 'gomaxprocs', 'host', 'http_base_path', 'http_host', 'http_port', 'http_req_stats', 'https_port', 'in_bytes', 'in_msgs', 'jetstream', 'leaf', 'leafnodes', 'max_connections', 'max_control_line', 'max_payload', 'max_pending', 'mem', 'now', 'out_bytes', 'out_msgs', 'ping_interval', 'ping_max', 'port', 'proto', 'remotes', 'routes', 'server_id', 'server_name', 'slow_consumers', 'start', 'subscriptions', 'system_account', 'tls_timeout', 'total_connections', 'uptime', 'version', 'write_deadline')

additional_keys (kittycad.models.connection.Connection property)

additional_properties (kittycad.models.connection.Connection attribute)

config_load_time (kittycad.models.connection.Connection attribute)

from_dict() (kittycad.models.connection.Connection class method)

http_base_path (kittycad.models.connection.Connection attribute)

http_req_stats (kittycad.models.connection.Connection attribute)

max_connections (kittycad.models.connection.Connection attribute)

max_control_line (kittycad.models.connection.Connection attribute)

slow_consumers (kittycad.models.connection.Connection attribute)

system_account (kittycad.models.connection.Connection attribute)

total_connections (kittycad.models.connection.Connection attribute)

write_deadline (kittycad.models.connection.Connection attribute)

__init__([auth_timeout, cluster, ...])

Method generated by attrs for class Connection.

rtype

TypeVar(ON, bound= Connection)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.connection.Connection.__init__>`\ \(\[auth\_timeout\, cluster\, ...\]\)

:py:obj:`to_dict <kittycad.models.connection.Connection.to_dict>`\ \(\)

cluster

config_load_time

connections

cores

cpu

gateway

git_commit

go

gomaxprocs

host

http_base_path

http_host

http_port

http_req_stats

https_port

in_bytes

in_msgs

jetstream

leaf

leafnodes

max_connections

max_control_line

max_payload

max_pending

mem

now

out_bytes

out_msgs

ping_interval

ping_max

port

proto

remotes

routes

server_id

server_name

slow_consumers

start

subscriptions

system_account

total_connections

uptime

version

write_deadline

CountryCode(value[, names, module, ...])

An enumeration of all ISO-3166 alpha-2 country codes.

:py:obj:`CountryCode <kittycad.models.country_code.CountryCode>`\ \(value\[\, names\, module\, ...\]\)

CountryCode(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.country_code.CountryCode attribute)

__contains__() (kittycad.models.country_code.CountryCode method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.country_code', '__doc__': 'An enumeration of all ISO-3166 alpha-2 country codes.', '__str__': <function CountryCode.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AI', 'AQ', 'AG', 'AR', 'AM', 'AW', 'AU', 'AT', 'AZ', 'BS', 'BH', 'BD', 'BB', 'BY', 'BE', 'BZ', 'BJ', 'BM', 'BT', 'BO', 'BQ', 'BA', 'BW', 'BV', 'BR', 'IO', 'BN', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'KY', 'CF', 'TD', 'CL', 'CN', 'CX', 'CC', 'CO', 'KM', 'CG', 'CD', 'CK', 'CR', 'CI', 'HR', 'CU', 'CW', 'CY', 'CZ', 'DK', 'DJ', 'DM', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FK', 'FO', 'FJ', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GD', 'GP', 'GU', 'GT', 'GG', 'GN', 'GW', 'GY', 'HT', 'HM', 'VA', 'HN', 'HK', 'HU', 'IS', 'IN', 'ID', 'IR', 'IQ', 'IE', 'IM', 'IL', 'IT', 'JM', 'JP', 'JE', 'JO', 'KZ', 'KE', 'KI', 'KP', 'KR', 'KW', 'KG', 'LA', 'LV', 'LB', 'LS', 'LR', 'LY', 'LI', 'LT', 'LU', 'MO', 'MK', 'MG', 'MW', 'MY', 'MV', 'ML', 'MT', 'MH', 'MQ', 'MR', 'MU', 'YT', 'MX', 'FM', 'MD', 'MC', 'MN', 'ME', 'MS', 'MA', 'MZ', 'MM', 'NA', 'NR', 'NP', 'NL', 'NC', 'NZ', 'NI', 'NE', 'NG', 'NU', 'NF', 'MP', 'NO', 'OM', 'PK', 'PW', 'PS', 'PA', 'PG', 'PY', 'PE', 'PH', 'PN', 'PL', 'PT', 'PR', 'QA', 'RE', 'RO', 'RU', 'RW', 'BL', 'SH', 'KN', 'LC', 'MF', 'PM', 'VC', 'WS', 'SM', 'ST', 'SA', 'SN', 'RS', 'SC', 'SL', 'SG', 'SX', 'SK', 'SI', 'SB', 'SO', 'ZA', 'GS', 'SS', 'ES', 'LK', 'SD', 'SR', 'SJ', 'SZ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'TZ', 'TH', 'TL', 'TG', 'TK', 'TO', 'TT', 'TN', 'TR', 'TM', 'TC', 'TV', 'UG', 'UA', 'AE', 'GB', 'US', 'UM', 'UY', 'UZ', 'VU', 'VE', 'VN', 'VG', 'VI', 'WF', 'EH', 'YE', 'ZM', 'ZW'], '_member_map_': {'AF': <CountryCode.AF: 'AF'>, 'AX': <CountryCode.AX: 'AX'>, 'AL': <CountryCode.AL: 'AL'>, 'DZ': <CountryCode.DZ: 'DZ'>, 'AS': <CountryCode.AS: 'AS'>, 'AD': <CountryCode.AD: 'AD'>, 'AO': <CountryCode.AO: 'AO'>, 'AI': <CountryCode.AI: 'AI'>, 'AQ': <CountryCode.AQ: 'AQ'>, 'AG': <CountryCode.AG: 'AG'>, 'AR': <CountryCode.AR: 'AR'>, 'AM': <CountryCode.AM: 'AM'>, 'AW': <CountryCode.AW: 'AW'>, 'AU': <CountryCode.AU: 'AU'>, 'AT': <CountryCode.AT: 'AT'>, 'AZ': <CountryCode.AZ: 'AZ'>, 'BS': <CountryCode.BS: 'BS'>, 'BH': <CountryCode.BH: 'BH'>, 'BD': <CountryCode.BD: 'BD'>, 'BB': <CountryCode.BB: 'BB'>, 'BY': <CountryCode.BY: 'BY'>, 'BE': <CountryCode.BE: 'BE'>, 'BZ': <CountryCode.BZ: 'BZ'>, 'BJ': <CountryCode.BJ: 'BJ'>, 'BM': <CountryCode.BM: 'BM'>, 'BT': <CountryCode.BT: 'BT'>, 'BO': <CountryCode.BO: 'BO'>, 'BQ': <CountryCode.BQ: 'BQ'>, 'BA': <CountryCode.BA: 'BA'>, 'BW': <CountryCode.BW: 'BW'>, 'BV': <CountryCode.BV: 'BV'>, 'BR': <CountryCode.BR: 'BR'>, 'IO': <CountryCode.IO: 'IO'>, 'BN': <CountryCode.BN: 'BN'>, 'BG': <CountryCode.BG: 'BG'>, 'BF': <CountryCode.BF: 'BF'>, 'BI': <CountryCode.BI: 'BI'>, 'CV': <CountryCode.CV: 'CV'>, 'KH': <CountryCode.KH: 'KH'>, 'CM': <CountryCode.CM: 'CM'>, 'CA': <CountryCode.CA: 'CA'>, 'KY': <CountryCode.KY: 'KY'>, 'CF': <CountryCode.CF: 'CF'>, 'TD': <CountryCode.TD: 'TD'>, 'CL': <CountryCode.CL: 'CL'>, 'CN': <CountryCode.CN: 'CN'>, 'CX': <CountryCode.CX: 'CX'>, 'CC': <CountryCode.CC: 'CC'>, 'CO': <CountryCode.CO: 'CO'>, 'KM': <CountryCode.KM: 'KM'>, 'CG': <CountryCode.CG: 'CG'>, 'CD': <CountryCode.CD: 'CD'>, 'CK': <CountryCode.CK: 'CK'>, 'CR': <CountryCode.CR: 'CR'>, 'CI': <CountryCode.CI: 'CI'>, 'HR': <CountryCode.HR: 'HR'>, 'CU': <CountryCode.CU: 'CU'>, 'CW': <CountryCode.CW: 'CW'>, 'CY': <CountryCode.CY: 'CY'>, 'CZ': <CountryCode.CZ: 'CZ'>, 'DK': <CountryCode.DK: 'DK'>, 'DJ': <CountryCode.DJ: 'DJ'>, 'DM': <CountryCode.DM: 'DM'>, 'DO': <CountryCode.DO: 'DO'>, 'EC': <CountryCode.EC: 'EC'>, 'EG': <CountryCode.EG: 'EG'>, 'SV': <CountryCode.SV: 'SV'>, 'GQ': <CountryCode.GQ: 'GQ'>, 'ER': <CountryCode.ER: 'ER'>, 'EE': <CountryCode.EE: 'EE'>, 'ET': <CountryCode.ET: 'ET'>, 'FK': <CountryCode.FK: 'FK'>, 'FO': <CountryCode.FO: 'FO'>, 'FJ': <CountryCode.FJ: 'FJ'>, 'FI': <CountryCode.FI: 'FI'>, 'FR': <CountryCode.FR: 'FR'>, 'GF': <CountryCode.GF: 'GF'>, 'PF': <CountryCode.PF: 'PF'>, 'TF': <CountryCode.TF: 'TF'>, 'GA': <CountryCode.GA: 'GA'>, 'GM': <CountryCode.GM: 'GM'>, 'GE': <CountryCode.GE: 'GE'>, 'DE': <CountryCode.DE: 'DE'>, 'GH': <CountryCode.GH: 'GH'>, 'GI': <CountryCode.GI: 'GI'>, 'GR': <CountryCode.GR: 'GR'>, 'GL': <CountryCode.GL: 'GL'>, 'GD': <CountryCode.GD: 'GD'>, 'GP': <CountryCode.GP: 'GP'>, 'GU': <CountryCode.GU: 'GU'>, 'GT': <CountryCode.GT: 'GT'>, 'GG': <CountryCode.GG: 'GG'>, 'GN': <CountryCode.GN: 'GN'>, 'GW': <CountryCode.GW: 'GW'>, 'GY': <CountryCode.GY: 'GY'>, 'HT': <CountryCode.HT: 'HT'>, 'HM': <CountryCode.HM: 'HM'>, 'VA': <CountryCode.VA: 'VA'>, 'HN': <CountryCode.HN: 'HN'>, 'HK': <CountryCode.HK: 'HK'>, 'HU': <CountryCode.HU: 'HU'>, 'IS': <CountryCode.IS: 'IS'>, 'IN': <CountryCode.IN: 'IN'>, 'ID': <CountryCode.ID: 'ID'>, 'IR': <CountryCode.IR: 'IR'>, 'IQ': <CountryCode.IQ: 'IQ'>, 'IE': <CountryCode.IE: 'IE'>, 'IM': <CountryCode.IM: 'IM'>, 'IL': <CountryCode.IL: 'IL'>, 'IT': <CountryCode.IT: 'IT'>, 'JM': <CountryCode.JM: 'JM'>, 'JP': <CountryCode.JP: 'JP'>, 'JE': <CountryCode.JE: 'JE'>, 'JO': <CountryCode.JO: 'JO'>, 'KZ': <CountryCode.KZ: 'KZ'>, 'KE': <CountryCode.KE: 'KE'>, 'KI': <CountryCode.KI: 'KI'>, 'KP': <CountryCode.KP: 'KP'>, 'KR': <CountryCode.KR: 'KR'>, 'KW': <CountryCode.KW: 'KW'>, 'KG': <CountryCode.KG: 'KG'>, 'LA': <CountryCode.LA: 'LA'>, 'LV': <CountryCode.LV: 'LV'>, 'LB': <CountryCode.LB: 'LB'>, 'LS': <CountryCode.LS: 'LS'>, 'LR': <CountryCode.LR: 'LR'>, 'LY': <CountryCode.LY: 'LY'>, 'LI': <CountryCode.LI: 'LI'>, 'LT': <CountryCode.LT: 'LT'>, 'LU': <CountryCode.LU: 'LU'>, 'MO': <CountryCode.MO: 'MO'>, 'MK': <CountryCode.MK: 'MK'>, 'MG': <CountryCode.MG: 'MG'>, 'MW': <CountryCode.MW: 'MW'>, 'MY': <CountryCode.MY: 'MY'>, 'MV': <CountryCode.MV: 'MV'>, 'ML': <CountryCode.ML: 'ML'>, 'MT': <CountryCode.MT: 'MT'>, 'MH': <CountryCode.MH: 'MH'>, 'MQ': <CountryCode.MQ: 'MQ'>, 'MR': <CountryCode.MR: 'MR'>, 'MU': <CountryCode.MU: 'MU'>, 'YT': <CountryCode.YT: 'YT'>, 'MX': <CountryCode.MX: 'MX'>, 'FM': <CountryCode.FM: 'FM'>, 'MD': <CountryCode.MD: 'MD'>, 'MC': <CountryCode.MC: 'MC'>, 'MN': <CountryCode.MN: 'MN'>, 'ME': <CountryCode.ME: 'ME'>, 'MS': <CountryCode.MS: 'MS'>, 'MA': <CountryCode.MA: 'MA'>, 'MZ': <CountryCode.MZ: 'MZ'>, 'MM': <CountryCode.MM: 'MM'>, 'NA': <CountryCode.NA: 'NA'>, 'NR': <CountryCode.NR: 'NR'>, 'NP': <CountryCode.NP: 'NP'>, 'NL': <CountryCode.NL: 'NL'>, 'NC': <CountryCode.NC: 'NC'>, 'NZ': <CountryCode.NZ: 'NZ'>, 'NI': <CountryCode.NI: 'NI'>, 'NE': <CountryCode.NE: 'NE'>, 'NG': <CountryCode.NG: 'NG'>, 'NU': <CountryCode.NU: 'NU'>, 'NF': <CountryCode.NF: 'NF'>, 'MP': <CountryCode.MP: 'MP'>, 'NO': <CountryCode.NO: 'NO'>, 'OM': <CountryCode.OM: 'OM'>, 'PK': <CountryCode.PK: 'PK'>, 'PW': <CountryCode.PW: 'PW'>, 'PS': <CountryCode.PS: 'PS'>, 'PA': <CountryCode.PA: 'PA'>, 'PG': <CountryCode.PG: 'PG'>, 'PY': <CountryCode.PY: 'PY'>, 'PE': <CountryCode.PE: 'PE'>, 'PH': <CountryCode.PH: 'PH'>, 'PN': <CountryCode.PN: 'PN'>, 'PL': <CountryCode.PL: 'PL'>, 'PT': <CountryCode.PT: 'PT'>, 'PR': <CountryCode.PR: 'PR'>, 'QA': <CountryCode.QA: 'QA'>, 'RE': <CountryCode.RE: 'RE'>, 'RO': <CountryCode.RO: 'RO'>, 'RU': <CountryCode.RU: 'RU'>, 'RW': <CountryCode.RW: 'RW'>, 'BL': <CountryCode.BL: 'BL'>, 'SH': <CountryCode.SH: 'SH'>, 'KN': <CountryCode.KN: 'KN'>, 'LC': <CountryCode.LC: 'LC'>, 'MF': <CountryCode.MF: 'MF'>, 'PM': <CountryCode.PM: 'PM'>, 'VC': <CountryCode.VC: 'VC'>, 'WS': <CountryCode.WS: 'WS'>, 'SM': <CountryCode.SM: 'SM'>, 'ST': <CountryCode.ST: 'ST'>, 'SA': <CountryCode.SA: 'SA'>, 'SN': <CountryCode.SN: 'SN'>, 'RS': <CountryCode.RS: 'RS'>, 'SC': <CountryCode.SC: 'SC'>, 'SL': <CountryCode.SL: 'SL'>, 'SG': <CountryCode.SG: 'SG'>, 'SX': <CountryCode.SX: 'SX'>, 'SK': <CountryCode.SK: 'SK'>, 'SI': <CountryCode.SI: 'SI'>, 'SB': <CountryCode.SB: 'SB'>, 'SO': <CountryCode.SO: 'SO'>, 'ZA': <CountryCode.ZA: 'ZA'>, 'GS': <CountryCode.GS: 'GS'>, 'SS': <CountryCode.SS: 'SS'>, 'ES': <CountryCode.ES: 'ES'>, 'LK': <CountryCode.LK: 'LK'>, 'SD': <CountryCode.SD: 'SD'>, 'SR': <CountryCode.SR: 'SR'>, 'SJ': <CountryCode.SJ: 'SJ'>, 'SZ': <CountryCode.SZ: 'SZ'>, 'SE': <CountryCode.SE: 'SE'>, 'CH': <CountryCode.CH: 'CH'>, 'SY': <CountryCode.SY: 'SY'>, 'TW': <CountryCode.TW: 'TW'>, 'TJ': <CountryCode.TJ: 'TJ'>, 'TZ': <CountryCode.TZ: 'TZ'>, 'TH': <CountryCode.TH: 'TH'>, 'TL': <CountryCode.TL: 'TL'>, 'TG': <CountryCode.TG: 'TG'>, 'TK': <CountryCode.TK: 'TK'>, 'TO': <CountryCode.TO: 'TO'>, 'TT': <CountryCode.TT: 'TT'>, 'TN': <CountryCode.TN: 'TN'>, 'TR': <CountryCode.TR: 'TR'>, 'TM': <CountryCode.TM: 'TM'>, 'TC': <CountryCode.TC: 'TC'>, 'TV': <CountryCode.TV: 'TV'>, 'UG': <CountryCode.UG: 'UG'>, 'UA': <CountryCode.UA: 'UA'>, 'AE': <CountryCode.AE: 'AE'>, 'GB': <CountryCode.GB: 'GB'>, 'US': <CountryCode.US: 'US'>, 'UM': <CountryCode.UM: 'UM'>, 'UY': <CountryCode.UY: 'UY'>, 'UZ': <CountryCode.UZ: 'UZ'>, 'VU': <CountryCode.VU: 'VU'>, 'VE': <CountryCode.VE: 'VE'>, 'VN': <CountryCode.VN: 'VN'>, 'VG': <CountryCode.VG: 'VG'>, 'VI': <CountryCode.VI: 'VI'>, 'WF': <CountryCode.WF: 'WF'>, 'EH': <CountryCode.EH: 'EH'>, 'YE': <CountryCode.YE: 'YE'>, 'ZM': <CountryCode.ZM: 'ZM'>, 'ZW': <CountryCode.ZW: 'ZW'>}, '_value2member_map_': {'AF': <CountryCode.AF: 'AF'>, 'AX': <CountryCode.AX: 'AX'>, 'AL': <CountryCode.AL: 'AL'>, 'DZ': <CountryCode.DZ: 'DZ'>, 'AS': <CountryCode.AS: 'AS'>, 'AD': <CountryCode.AD: 'AD'>, 'AO': <CountryCode.AO: 'AO'>, 'AI': <CountryCode.AI: 'AI'>, 'AQ': <CountryCode.AQ: 'AQ'>, 'AG': <CountryCode.AG: 'AG'>, 'AR': <CountryCode.AR: 'AR'>, 'AM': <CountryCode.AM: 'AM'>, 'AW': <CountryCode.AW: 'AW'>, 'AU': <CountryCode.AU: 'AU'>, 'AT': <CountryCode.AT: 'AT'>, 'AZ': <CountryCode.AZ: 'AZ'>, 'BS': <CountryCode.BS: 'BS'>, 'BH': <CountryCode.BH: 'BH'>, 'BD': <CountryCode.BD: 'BD'>, 'BB': <CountryCode.BB: 'BB'>, 'BY': <CountryCode.BY: 'BY'>, 'BE': <CountryCode.BE: 'BE'>, 'BZ': <CountryCode.BZ: 'BZ'>, 'BJ': <CountryCode.BJ: 'BJ'>, 'BM': <CountryCode.BM: 'BM'>, 'BT': <CountryCode.BT: 'BT'>, 'BO': <CountryCode.BO: 'BO'>, 'BQ': <CountryCode.BQ: 'BQ'>, 'BA': <CountryCode.BA: 'BA'>, 'BW': <CountryCode.BW: 'BW'>, 'BV': <CountryCode.BV: 'BV'>, 'BR': <CountryCode.BR: 'BR'>, 'IO': <CountryCode.IO: 'IO'>, 'BN': <CountryCode.BN: 'BN'>, 'BG': <CountryCode.BG: 'BG'>, 'BF': <CountryCode.BF: 'BF'>, 'BI': <CountryCode.BI: 'BI'>, 'CV': <CountryCode.CV: 'CV'>, 'KH': <CountryCode.KH: 'KH'>, 'CM': <CountryCode.CM: 'CM'>, 'CA': <CountryCode.CA: 'CA'>, 'KY': <CountryCode.KY: 'KY'>, 'CF': <CountryCode.CF: 'CF'>, 'TD': <CountryCode.TD: 'TD'>, 'CL': <CountryCode.CL: 'CL'>, 'CN': <CountryCode.CN: 'CN'>, 'CX': <CountryCode.CX: 'CX'>, 'CC': <CountryCode.CC: 'CC'>, 'CO': <CountryCode.CO: 'CO'>, 'KM': <CountryCode.KM: 'KM'>, 'CG': <CountryCode.CG: 'CG'>, 'CD': <CountryCode.CD: 'CD'>, 'CK': <CountryCode.CK: 'CK'>, 'CR': <CountryCode.CR: 'CR'>, 'CI': <CountryCode.CI: 'CI'>, 'HR': <CountryCode.HR: 'HR'>, 'CU': <CountryCode.CU: 'CU'>, 'CW': <CountryCode.CW: 'CW'>, 'CY': <CountryCode.CY: 'CY'>, 'CZ': <CountryCode.CZ: 'CZ'>, 'DK': <CountryCode.DK: 'DK'>, 'DJ': <CountryCode.DJ: 'DJ'>, 'DM': <CountryCode.DM: 'DM'>, 'DO': <CountryCode.DO: 'DO'>, 'EC': <CountryCode.EC: 'EC'>, 'EG': <CountryCode.EG: 'EG'>, 'SV': <CountryCode.SV: 'SV'>, 'GQ': <CountryCode.GQ: 'GQ'>, 'ER': <CountryCode.ER: 'ER'>, 'EE': <CountryCode.EE: 'EE'>, 'ET': <CountryCode.ET: 'ET'>, 'FK': <CountryCode.FK: 'FK'>, 'FO': <CountryCode.FO: 'FO'>, 'FJ': <CountryCode.FJ: 'FJ'>, 'FI': <CountryCode.FI: 'FI'>, 'FR': <CountryCode.FR: 'FR'>, 'GF': <CountryCode.GF: 'GF'>, 'PF': <CountryCode.PF: 'PF'>, 'TF': <CountryCode.TF: 'TF'>, 'GA': <CountryCode.GA: 'GA'>, 'GM': <CountryCode.GM: 'GM'>, 'GE': <CountryCode.GE: 'GE'>, 'DE': <CountryCode.DE: 'DE'>, 'GH': <CountryCode.GH: 'GH'>, 'GI': <CountryCode.GI: 'GI'>, 'GR': <CountryCode.GR: 'GR'>, 'GL': <CountryCode.GL: 'GL'>, 'GD': <CountryCode.GD: 'GD'>, 'GP': <CountryCode.GP: 'GP'>, 'GU': <CountryCode.GU: 'GU'>, 'GT': <CountryCode.GT: 'GT'>, 'GG': <CountryCode.GG: 'GG'>, 'GN': <CountryCode.GN: 'GN'>, 'GW': <CountryCode.GW: 'GW'>, 'GY': <CountryCode.GY: 'GY'>, 'HT': <CountryCode.HT: 'HT'>, 'HM': <CountryCode.HM: 'HM'>, 'VA': <CountryCode.VA: 'VA'>, 'HN': <CountryCode.HN: 'HN'>, 'HK': <CountryCode.HK: 'HK'>, 'HU': <CountryCode.HU: 'HU'>, 'IS': <CountryCode.IS: 'IS'>, 'IN': <CountryCode.IN: 'IN'>, 'ID': <CountryCode.ID: 'ID'>, 'IR': <CountryCode.IR: 'IR'>, 'IQ': <CountryCode.IQ: 'IQ'>, 'IE': <CountryCode.IE: 'IE'>, 'IM': <CountryCode.IM: 'IM'>, 'IL': <CountryCode.IL: 'IL'>, 'IT': <CountryCode.IT: 'IT'>, 'JM': <CountryCode.JM: 'JM'>, 'JP': <CountryCode.JP: 'JP'>, 'JE': <CountryCode.JE: 'JE'>, 'JO': <CountryCode.JO: 'JO'>, 'KZ': <CountryCode.KZ: 'KZ'>, 'KE': <CountryCode.KE: 'KE'>, 'KI': <CountryCode.KI: 'KI'>, 'KP': <CountryCode.KP: 'KP'>, 'KR': <CountryCode.KR: 'KR'>, 'KW': <CountryCode.KW: 'KW'>, 'KG': <CountryCode.KG: 'KG'>, 'LA': <CountryCode.LA: 'LA'>, 'LV': <CountryCode.LV: 'LV'>, 'LB': <CountryCode.LB: 'LB'>, 'LS': <CountryCode.LS: 'LS'>, 'LR': <CountryCode.LR: 'LR'>, 'LY': <CountryCode.LY: 'LY'>, 'LI': <CountryCode.LI: 'LI'>, 'LT': <CountryCode.LT: 'LT'>, 'LU': <CountryCode.LU: 'LU'>, 'MO': <CountryCode.MO: 'MO'>, 'MK': <CountryCode.MK: 'MK'>, 'MG': <CountryCode.MG: 'MG'>, 'MW': <CountryCode.MW: 'MW'>, 'MY': <CountryCode.MY: 'MY'>, 'MV': <CountryCode.MV: 'MV'>, 'ML': <CountryCode.ML: 'ML'>, 'MT': <CountryCode.MT: 'MT'>, 'MH': <CountryCode.MH: 'MH'>, 'MQ': <CountryCode.MQ: 'MQ'>, 'MR': <CountryCode.MR: 'MR'>, 'MU': <CountryCode.MU: 'MU'>, 'YT': <CountryCode.YT: 'YT'>, 'MX': <CountryCode.MX: 'MX'>, 'FM': <CountryCode.FM: 'FM'>, 'MD': <CountryCode.MD: 'MD'>, 'MC': <CountryCode.MC: 'MC'>, 'MN': <CountryCode.MN: 'MN'>, 'ME': <CountryCode.ME: 'ME'>, 'MS': <CountryCode.MS: 'MS'>, 'MA': <CountryCode.MA: 'MA'>, 'MZ': <CountryCode.MZ: 'MZ'>, 'MM': <CountryCode.MM: 'MM'>, 'NA': <CountryCode.NA: 'NA'>, 'NR': <CountryCode.NR: 'NR'>, 'NP': <CountryCode.NP: 'NP'>, 'NL': <CountryCode.NL: 'NL'>, 'NC': <CountryCode.NC: 'NC'>, 'NZ': <CountryCode.NZ: 'NZ'>, 'NI': <CountryCode.NI: 'NI'>, 'NE': <CountryCode.NE: 'NE'>, 'NG': <CountryCode.NG: 'NG'>, 'NU': <CountryCode.NU: 'NU'>, 'NF': <CountryCode.NF: 'NF'>, 'MP': <CountryCode.MP: 'MP'>, 'NO': <CountryCode.NO: 'NO'>, 'OM': <CountryCode.OM: 'OM'>, 'PK': <CountryCode.PK: 'PK'>, 'PW': <CountryCode.PW: 'PW'>, 'PS': <CountryCode.PS: 'PS'>, 'PA': <CountryCode.PA: 'PA'>, 'PG': <CountryCode.PG: 'PG'>, 'PY': <CountryCode.PY: 'PY'>, 'PE': <CountryCode.PE: 'PE'>, 'PH': <CountryCode.PH: 'PH'>, 'PN': <CountryCode.PN: 'PN'>, 'PL': <CountryCode.PL: 'PL'>, 'PT': <CountryCode.PT: 'PT'>, 'PR': <CountryCode.PR: 'PR'>, 'QA': <CountryCode.QA: 'QA'>, 'RE': <CountryCode.RE: 'RE'>, 'RO': <CountryCode.RO: 'RO'>, 'RU': <CountryCode.RU: 'RU'>, 'RW': <CountryCode.RW: 'RW'>, 'BL': <CountryCode.BL: 'BL'>, 'SH': <CountryCode.SH: 'SH'>, 'KN': <CountryCode.KN: 'KN'>, 'LC': <CountryCode.LC: 'LC'>, 'MF': <CountryCode.MF: 'MF'>, 'PM': <CountryCode.PM: 'PM'>, 'VC': <CountryCode.VC: 'VC'>, 'WS': <CountryCode.WS: 'WS'>, 'SM': <CountryCode.SM: 'SM'>, 'ST': <CountryCode.ST: 'ST'>, 'SA': <CountryCode.SA: 'SA'>, 'SN': <CountryCode.SN: 'SN'>, 'RS': <CountryCode.RS: 'RS'>, 'SC': <CountryCode.SC: 'SC'>, 'SL': <CountryCode.SL: 'SL'>, 'SG': <CountryCode.SG: 'SG'>, 'SX': <CountryCode.SX: 'SX'>, 'SK': <CountryCode.SK: 'SK'>, 'SI': <CountryCode.SI: 'SI'>, 'SB': <CountryCode.SB: 'SB'>, 'SO': <CountryCode.SO: 'SO'>, 'ZA': <CountryCode.ZA: 'ZA'>, 'GS': <CountryCode.GS: 'GS'>, 'SS': <CountryCode.SS: 'SS'>, 'ES': <CountryCode.ES: 'ES'>, 'LK': <CountryCode.LK: 'LK'>, 'SD': <CountryCode.SD: 'SD'>, 'SR': <CountryCode.SR: 'SR'>, 'SJ': <CountryCode.SJ: 'SJ'>, 'SZ': <CountryCode.SZ: 'SZ'>, 'SE': <CountryCode.SE: 'SE'>, 'CH': <CountryCode.CH: 'CH'>, 'SY': <CountryCode.SY: 'SY'>, 'TW': <CountryCode.TW: 'TW'>, 'TJ': <CountryCode.TJ: 'TJ'>, 'TZ': <CountryCode.TZ: 'TZ'>, 'TH': <CountryCode.TH: 'TH'>, 'TL': <CountryCode.TL: 'TL'>, 'TG': <CountryCode.TG: 'TG'>, 'TK': <CountryCode.TK: 'TK'>, 'TO': <CountryCode.TO: 'TO'>, 'TT': <CountryCode.TT: 'TT'>, 'TN': <CountryCode.TN: 'TN'>, 'TR': <CountryCode.TR: 'TR'>, 'TM': <CountryCode.TM: 'TM'>, 'TC': <CountryCode.TC: 'TC'>, 'TV': <CountryCode.TV: 'TV'>, 'UG': <CountryCode.UG: 'UG'>, 'UA': <CountryCode.UA: 'UA'>, 'AE': <CountryCode.AE: 'AE'>, 'GB': <CountryCode.GB: 'GB'>, 'US': <CountryCode.US: 'US'>, 'UM': <CountryCode.UM: 'UM'>, 'UY': <CountryCode.UY: 'UY'>, 'UZ': <CountryCode.UZ: 'UZ'>, 'VU': <CountryCode.VU: 'VU'>, 'VE': <CountryCode.VE: 'VE'>, 'VN': <CountryCode.VN: 'VN'>, 'VG': <CountryCode.VG: 'VG'>, 'VI': <CountryCode.VI: 'VI'>, 'WF': <CountryCode.WF: 'WF'>, 'EH': <CountryCode.EH: 'EH'>, 'YE': <CountryCode.YE: 'YE'>, 'ZM': <CountryCode.ZM: 'ZM'>, 'ZW': <CountryCode.ZW: 'ZW'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'CountryCode' objects>, '__weakref__': <attribute '__weakref__' of 'CountryCode' objects>, 'AF': <CountryCode.AF: 'AF'>, 'AX': <CountryCode.AX: 'AX'>, 'AL': <CountryCode.AL: 'AL'>, 'DZ': <CountryCode.DZ: 'DZ'>, 'AS': <CountryCode.AS: 'AS'>, 'AD': <CountryCode.AD: 'AD'>, 'AO': <CountryCode.AO: 'AO'>, 'AI': <CountryCode.AI: 'AI'>, 'AQ': <CountryCode.AQ: 'AQ'>, 'AG': <CountryCode.AG: 'AG'>, 'AR': <CountryCode.AR: 'AR'>, 'AM': <CountryCode.AM: 'AM'>, 'AW': <CountryCode.AW: 'AW'>, 'AU': <CountryCode.AU: 'AU'>, 'AT': <CountryCode.AT: 'AT'>, 'AZ': <CountryCode.AZ: 'AZ'>, 'BS': <CountryCode.BS: 'BS'>, 'BH': <CountryCode.BH: 'BH'>, 'BD': <CountryCode.BD: 'BD'>, 'BB': <CountryCode.BB: 'BB'>, 'BY': <CountryCode.BY: 'BY'>, 'BE': <CountryCode.BE: 'BE'>, 'BZ': <CountryCode.BZ: 'BZ'>, 'BJ': <CountryCode.BJ: 'BJ'>, 'BM': <CountryCode.BM: 'BM'>, 'BT': <CountryCode.BT: 'BT'>, 'BO': <CountryCode.BO: 'BO'>, 'BQ': <CountryCode.BQ: 'BQ'>, 'BA': <CountryCode.BA: 'BA'>, 'BW': <CountryCode.BW: 'BW'>, 'BV': <CountryCode.BV: 'BV'>, 'BR': <CountryCode.BR: 'BR'>, 'IO': <CountryCode.IO: 'IO'>, 'BN': <CountryCode.BN: 'BN'>, 'BG': <CountryCode.BG: 'BG'>, 'BF': <CountryCode.BF: 'BF'>, 'BI': <CountryCode.BI: 'BI'>, 'CV': <CountryCode.CV: 'CV'>, 'KH': <CountryCode.KH: 'KH'>, 'CM': <CountryCode.CM: 'CM'>, 'CA': <CountryCode.CA: 'CA'>, 'KY': <CountryCode.KY: 'KY'>, 'CF': <CountryCode.CF: 'CF'>, 'TD': <CountryCode.TD: 'TD'>, 'CL': <CountryCode.CL: 'CL'>, 'CN': <CountryCode.CN: 'CN'>, 'CX': <CountryCode.CX: 'CX'>, 'CC': <CountryCode.CC: 'CC'>, 'CO': <CountryCode.CO: 'CO'>, 'KM': <CountryCode.KM: 'KM'>, 'CG': <CountryCode.CG: 'CG'>, 'CD': <CountryCode.CD: 'CD'>, 'CK': <CountryCode.CK: 'CK'>, 'CR': <CountryCode.CR: 'CR'>, 'CI': <CountryCode.CI: 'CI'>, 'HR': <CountryCode.HR: 'HR'>, 'CU': <CountryCode.CU: 'CU'>, 'CW': <CountryCode.CW: 'CW'>, 'CY': <CountryCode.CY: 'CY'>, 'CZ': <CountryCode.CZ: 'CZ'>, 'DK': <CountryCode.DK: 'DK'>, 'DJ': <CountryCode.DJ: 'DJ'>, 'DM': <CountryCode.DM: 'DM'>, 'DO': <CountryCode.DO: 'DO'>, 'EC': <CountryCode.EC: 'EC'>, 'EG': <CountryCode.EG: 'EG'>, 'SV': <CountryCode.SV: 'SV'>, 'GQ': <CountryCode.GQ: 'GQ'>, 'ER': <CountryCode.ER: 'ER'>, 'EE': <CountryCode.EE: 'EE'>, 'ET': <CountryCode.ET: 'ET'>, 'FK': <CountryCode.FK: 'FK'>, 'FO': <CountryCode.FO: 'FO'>, 'FJ': <CountryCode.FJ: 'FJ'>, 'FI': <CountryCode.FI: 'FI'>, 'FR': <CountryCode.FR: 'FR'>, 'GF': <CountryCode.GF: 'GF'>, 'PF': <CountryCode.PF: 'PF'>, 'TF': <CountryCode.TF: 'TF'>, 'GA': <CountryCode.GA: 'GA'>, 'GM': <CountryCode.GM: 'GM'>, 'GE': <CountryCode.GE: 'GE'>, 'DE': <CountryCode.DE: 'DE'>, 'GH': <CountryCode.GH: 'GH'>, 'GI': <CountryCode.GI: 'GI'>, 'GR': <CountryCode.GR: 'GR'>, 'GL': <CountryCode.GL: 'GL'>, 'GD': <CountryCode.GD: 'GD'>, 'GP': <CountryCode.GP: 'GP'>, 'GU': <CountryCode.GU: 'GU'>, 'GT': <CountryCode.GT: 'GT'>, 'GG': <CountryCode.GG: 'GG'>, 'GN': <CountryCode.GN: 'GN'>, 'GW': <CountryCode.GW: 'GW'>, 'GY': <CountryCode.GY: 'GY'>, 'HT': <CountryCode.HT: 'HT'>, 'HM': <CountryCode.HM: 'HM'>, 'VA': <CountryCode.VA: 'VA'>, 'HN': <CountryCode.HN: 'HN'>, 'HK': <CountryCode.HK: 'HK'>, 'HU': <CountryCode.HU: 'HU'>, 'IS': <CountryCode.IS: 'IS'>, 'IN': <CountryCode.IN: 'IN'>, 'ID': <CountryCode.ID: 'ID'>, 'IR': <CountryCode.IR: 'IR'>, 'IQ': <CountryCode.IQ: 'IQ'>, 'IE': <CountryCode.IE: 'IE'>, 'IM': <CountryCode.IM: 'IM'>, 'IL': <CountryCode.IL: 'IL'>, 'IT': <CountryCode.IT: 'IT'>, 'JM': <CountryCode.JM: 'JM'>, 'JP': <CountryCode.JP: 'JP'>, 'JE': <CountryCode.JE: 'JE'>, 'JO': <CountryCode.JO: 'JO'>, 'KZ': <CountryCode.KZ: 'KZ'>, 'KE': <CountryCode.KE: 'KE'>, 'KI': <CountryCode.KI: 'KI'>, 'KP': <CountryCode.KP: 'KP'>, 'KR': <CountryCode.KR: 'KR'>, 'KW': <CountryCode.KW: 'KW'>, 'KG': <CountryCode.KG: 'KG'>, 'LA': <CountryCode.LA: 'LA'>, 'LV': <CountryCode.LV: 'LV'>, 'LB': <CountryCode.LB: 'LB'>, 'LS': <CountryCode.LS: 'LS'>, 'LR': <CountryCode.LR: 'LR'>, 'LY': <CountryCode.LY: 'LY'>, 'LI': <CountryCode.LI: 'LI'>, 'LT': <CountryCode.LT: 'LT'>, 'LU': <CountryCode.LU: 'LU'>, 'MO': <CountryCode.MO: 'MO'>, 'MK': <CountryCode.MK: 'MK'>, 'MG': <CountryCode.MG: 'MG'>, 'MW': <CountryCode.MW: 'MW'>, 'MY': <CountryCode.MY: 'MY'>, 'MV': <CountryCode.MV: 'MV'>, 'ML': <CountryCode.ML: 'ML'>, 'MT': <CountryCode.MT: 'MT'>, 'MH': <CountryCode.MH: 'MH'>, 'MQ': <CountryCode.MQ: 'MQ'>, 'MR': <CountryCode.MR: 'MR'>, 'MU': <CountryCode.MU: 'MU'>, 'YT': <CountryCode.YT: 'YT'>, 'MX': <CountryCode.MX: 'MX'>, 'FM': <CountryCode.FM: 'FM'>, 'MD': <CountryCode.MD: 'MD'>, 'MC': <CountryCode.MC: 'MC'>, 'MN': <CountryCode.MN: 'MN'>, 'ME': <CountryCode.ME: 'ME'>, 'MS': <CountryCode.MS: 'MS'>, 'MA': <CountryCode.MA: 'MA'>, 'MZ': <CountryCode.MZ: 'MZ'>, 'MM': <CountryCode.MM: 'MM'>, 'NA': <CountryCode.NA: 'NA'>, 'NR': <CountryCode.NR: 'NR'>, 'NP': <CountryCode.NP: 'NP'>, 'NL': <CountryCode.NL: 'NL'>, 'NC': <CountryCode.NC: 'NC'>, 'NZ': <CountryCode.NZ: 'NZ'>, 'NI': <CountryCode.NI: 'NI'>, 'NE': <CountryCode.NE: 'NE'>, 'NG': <CountryCode.NG: 'NG'>, 'NU': <CountryCode.NU: 'NU'>, 'NF': <CountryCode.NF: 'NF'>, 'MP': <CountryCode.MP: 'MP'>, 'NO': <CountryCode.NO: 'NO'>, 'OM': <CountryCode.OM: 'OM'>, 'PK': <CountryCode.PK: 'PK'>, 'PW': <CountryCode.PW: 'PW'>, 'PS': <CountryCode.PS: 'PS'>, 'PA': <CountryCode.PA: 'PA'>, 'PG': <CountryCode.PG: 'PG'>, 'PY': <CountryCode.PY: 'PY'>, 'PE': <CountryCode.PE: 'PE'>, 'PH': <CountryCode.PH: 'PH'>, 'PN': <CountryCode.PN: 'PN'>, 'PL': <CountryCode.PL: 'PL'>, 'PT': <CountryCode.PT: 'PT'>, 'PR': <CountryCode.PR: 'PR'>, 'QA': <CountryCode.QA: 'QA'>, 'RE': <CountryCode.RE: 'RE'>, 'RO': <CountryCode.RO: 'RO'>, 'RU': <CountryCode.RU: 'RU'>, 'RW': <CountryCode.RW: 'RW'>, 'BL': <CountryCode.BL: 'BL'>, 'SH': <CountryCode.SH: 'SH'>, 'KN': <CountryCode.KN: 'KN'>, 'LC': <CountryCode.LC: 'LC'>, 'MF': <CountryCode.MF: 'MF'>, 'PM': <CountryCode.PM: 'PM'>, 'VC': <CountryCode.VC: 'VC'>, 'WS': <CountryCode.WS: 'WS'>, 'SM': <CountryCode.SM: 'SM'>, 'ST': <CountryCode.ST: 'ST'>, 'SA': <CountryCode.SA: 'SA'>, 'SN': <CountryCode.SN: 'SN'>, 'RS': <CountryCode.RS: 'RS'>, 'SC': <CountryCode.SC: 'SC'>, 'SL': <CountryCode.SL: 'SL'>, 'SG': <CountryCode.SG: 'SG'>, 'SX': <CountryCode.SX: 'SX'>, 'SK': <CountryCode.SK: 'SK'>, 'SI': <CountryCode.SI: 'SI'>, 'SB': <CountryCode.SB: 'SB'>, 'SO': <CountryCode.SO: 'SO'>, 'ZA': <CountryCode.ZA: 'ZA'>, 'GS': <CountryCode.GS: 'GS'>, 'SS': <CountryCode.SS: 'SS'>, 'ES': <CountryCode.ES: 'ES'>, 'LK': <CountryCode.LK: 'LK'>, 'SD': <CountryCode.SD: 'SD'>, 'SR': <CountryCode.SR: 'SR'>, 'SJ': <CountryCode.SJ: 'SJ'>, 'SZ': <CountryCode.SZ: 'SZ'>, 'SE': <CountryCode.SE: 'SE'>, 'CH': <CountryCode.CH: 'CH'>, 'SY': <CountryCode.SY: 'SY'>, 'TW': <CountryCode.TW: 'TW'>, 'TJ': <CountryCode.TJ: 'TJ'>, 'TZ': <CountryCode.TZ: 'TZ'>, 'TH': <CountryCode.TH: 'TH'>, 'TL': <CountryCode.TL: 'TL'>, 'TG': <CountryCode.TG: 'TG'>, 'TK': <CountryCode.TK: 'TK'>, 'TO': <CountryCode.TO: 'TO'>, 'TT': <CountryCode.TT: 'TT'>, 'TN': <CountryCode.TN: 'TN'>, 'TR': <CountryCode.TR: 'TR'>, 'TM': <CountryCode.TM: 'TM'>, 'TC': <CountryCode.TC: 'TC'>, 'TV': <CountryCode.TV: 'TV'>, 'UG': <CountryCode.UG: 'UG'>, 'UA': <CountryCode.UA: 'UA'>, 'AE': <CountryCode.AE: 'AE'>, 'GB': <CountryCode.GB: 'GB'>, 'US': <CountryCode.US: 'US'>, 'UM': <CountryCode.UM: 'UM'>, 'UY': <CountryCode.UY: 'UY'>, 'UZ': <CountryCode.UZ: 'UZ'>, 'VU': <CountryCode.VU: 'VU'>, 'VE': <CountryCode.VE: 'VE'>, 'VN': <CountryCode.VN: 'VN'>, 'VG': <CountryCode.VG: 'VG'>, 'VI': <CountryCode.VI: 'VI'>, 'WF': <CountryCode.WF: 'WF'>, 'EH': <CountryCode.EH: 'EH'>, 'YE': <CountryCode.YE: 'YE'>, 'ZM': <CountryCode.ZM: 'ZM'>, 'ZW': <CountryCode.ZW: 'ZW'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.country_code.CountryCode method)

__getnewargs__() (kittycad.models.country_code.CountryCode method)

__reduce_ex__() (kittycad.models.country_code.CountryCode method)

_generate_next_value_() (kittycad.models.country_code.CountryCode method)

_member_map_ (kittycad.models.country_code.CountryCode attribute)

{'AD': CountryCode.AD, 'AE': CountryCode.AE, 'AF': CountryCode.AF, 'AG': CountryCode.AG, 'AI': CountryCode.AI, 'AL': CountryCode.AL, 'AM': CountryCode.AM, 'AO': CountryCode.AO, 'AQ': CountryCode.AQ, 'AR': CountryCode.AR, 'AS': CountryCode.AS, 'AT': CountryCode.AT, 'AU': CountryCode.AU, 'AW': CountryCode.AW, 'AX': CountryCode.AX, 'AZ': CountryCode.AZ, 'BA': CountryCode.BA, 'BB': CountryCode.BB, 'BD': CountryCode.BD, 'BE': CountryCode.BE, 'BF': CountryCode.BF, 'BG': CountryCode.BG, 'BH': CountryCode.BH, 'BI': CountryCode.BI, 'BJ': CountryCode.BJ, 'BL': CountryCode.BL, 'BM': CountryCode.BM, 'BN': CountryCode.BN, 'BO': CountryCode.BO, 'BQ': CountryCode.BQ, 'BR': CountryCode.BR, 'BS': CountryCode.BS, 'BT': CountryCode.BT, 'BV': CountryCode.BV, 'BW': CountryCode.BW, 'BY': CountryCode.BY, 'BZ': CountryCode.BZ, 'CA': CountryCode.CA, 'CC': CountryCode.CC, 'CD': CountryCode.CD, 'CF': CountryCode.CF, 'CG': CountryCode.CG, 'CH': CountryCode.CH, 'CI': CountryCode.CI, 'CK': CountryCode.CK, 'CL': CountryCode.CL, 'CM': CountryCode.CM, 'CN': CountryCode.CN, 'CO': CountryCode.CO, 'CR': CountryCode.CR, 'CU': CountryCode.CU, 'CV': CountryCode.CV, 'CW': CountryCode.CW, 'CX': CountryCode.CX, 'CY': CountryCode.CY, 'CZ': CountryCode.CZ, 'DE': CountryCode.DE, 'DJ': CountryCode.DJ, 'DK': CountryCode.DK, 'DM': CountryCode.DM, 'DO': CountryCode.DO, 'DZ': CountryCode.DZ, 'EC': CountryCode.EC, 'EE': CountryCode.EE, 'EG': CountryCode.EG, 'EH': CountryCode.EH, 'ER': CountryCode.ER, 'ES': CountryCode.ES, 'ET': CountryCode.ET, 'FI': CountryCode.FI, 'FJ': CountryCode.FJ, 'FK': CountryCode.FK, 'FM': CountryCode.FM, 'FO': CountryCode.FO, 'FR': CountryCode.FR, 'GA': CountryCode.GA, 'GB': CountryCode.GB, 'GD': CountryCode.GD, 'GE': CountryCode.GE, 'GF': CountryCode.GF, 'GG': CountryCode.GG, 'GH': CountryCode.GH, 'GI': CountryCode.GI, 'GL': CountryCode.GL, 'GM': CountryCode.GM, 'GN': CountryCode.GN, 'GP': CountryCode.GP, 'GQ': CountryCode.GQ, 'GR': CountryCode.GR, 'GS': CountryCode.GS, 'GT': CountryCode.GT, 'GU': CountryCode.GU, 'GW': CountryCode.GW, 'GY': CountryCode.GY, 'HK': CountryCode.HK, 'HM': CountryCode.HM, 'HN': CountryCode.HN, 'HR': CountryCode.HR, 'HT': CountryCode.HT, 'HU': CountryCode.HU, 'ID': CountryCode.ID, 'IE': CountryCode.IE, 'IL': CountryCode.IL, 'IM': CountryCode.IM, 'IN': CountryCode.IN, 'IO': CountryCode.IO, 'IQ': CountryCode.IQ, 'IR': CountryCode.IR, 'IS': CountryCode.IS, 'IT': CountryCode.IT, 'JE': CountryCode.JE, 'JM': CountryCode.JM, 'JO': CountryCode.JO, 'JP': CountryCode.JP, 'KE': CountryCode.KE, 'KG': CountryCode.KG, 'KH': CountryCode.KH, 'KI': CountryCode.KI, 'KM': CountryCode.KM, 'KN': CountryCode.KN, 'KP': CountryCode.KP, 'KR': CountryCode.KR, 'KW': CountryCode.KW, 'KY': CountryCode.KY, 'KZ': CountryCode.KZ, 'LA': CountryCode.LA, 'LB': CountryCode.LB, 'LC': CountryCode.LC, 'LI': CountryCode.LI, 'LK': CountryCode.LK, 'LR': CountryCode.LR, 'LS': CountryCode.LS, 'LT': CountryCode.LT, 'LU': CountryCode.LU, 'LV': CountryCode.LV, 'LY': CountryCode.LY, 'MA': CountryCode.MA, 'MC': CountryCode.MC, 'MD': CountryCode.MD, 'ME': CountryCode.ME, 'MF': CountryCode.MF, 'MG': CountryCode.MG, 'MH': CountryCode.MH, 'MK': CountryCode.MK, 'ML': CountryCode.ML, 'MM': CountryCode.MM, 'MN': CountryCode.MN, 'MO': CountryCode.MO, 'MP': CountryCode.MP, 'MQ': CountryCode.MQ, 'MR': CountryCode.MR, 'MS': CountryCode.MS, 'MT': CountryCode.MT, 'MU': CountryCode.MU, 'MV': CountryCode.MV, 'MW': CountryCode.MW, 'MX': CountryCode.MX, 'MY': CountryCode.MY, 'MZ': CountryCode.MZ, 'NA': CountryCode.NA, 'NC': CountryCode.NC, 'NE': CountryCode.NE, 'NF': CountryCode.NF, 'NG': CountryCode.NG, 'NI': CountryCode.NI, 'NL': CountryCode.NL, 'NO': CountryCode.NO, 'NP': CountryCode.NP, 'NR': CountryCode.NR, 'NU': CountryCode.NU, 'NZ': CountryCode.NZ, 'OM': CountryCode.OM, 'PA': CountryCode.PA, 'PE': CountryCode.PE, 'PF': CountryCode.PF, 'PG': CountryCode.PG, 'PH': CountryCode.PH, 'PK': CountryCode.PK, 'PL': CountryCode.PL, 'PM': CountryCode.PM, 'PN': CountryCode.PN, 'PR': CountryCode.PR, 'PS': CountryCode.PS, 'PT': CountryCode.PT, 'PW': CountryCode.PW, 'PY': CountryCode.PY, 'QA': CountryCode.QA, 'RE': CountryCode.RE, 'RO': CountryCode.RO, 'RS': CountryCode.RS, 'RU': CountryCode.RU, 'RW': CountryCode.RW, 'SA': CountryCode.SA, 'SB': CountryCode.SB, 'SC': CountryCode.SC, 'SD': CountryCode.SD, 'SE': CountryCode.SE, 'SG': CountryCode.SG, 'SH': CountryCode.SH, 'SI': CountryCode.SI, 'SJ': CountryCode.SJ, 'SK': CountryCode.SK, 'SL': CountryCode.SL, 'SM': CountryCode.SM, 'SN': CountryCode.SN, 'SO': CountryCode.SO, 'SR': CountryCode.SR, 'SS': CountryCode.SS, 'ST': CountryCode.ST, 'SV': CountryCode.SV, 'SX': CountryCode.SX, 'SY': CountryCode.SY, 'SZ': CountryCode.SZ, 'TC': CountryCode.TC, 'TD': CountryCode.TD, 'TF': CountryCode.TF, 'TG': CountryCode.TG, 'TH': CountryCode.TH, 'TJ': CountryCode.TJ, 'TK': CountryCode.TK, 'TL': CountryCode.TL, 'TM': CountryCode.TM, 'TN': CountryCode.TN, 'TO': CountryCode.TO, 'TR': CountryCode.TR, 'TT': CountryCode.TT, 'TV': CountryCode.TV, 'TW': CountryCode.TW, 'TZ': CountryCode.TZ, 'UA': CountryCode.UA, 'UG': CountryCode.UG, 'UM': CountryCode.UM, 'US': CountryCode.US, 'UY': CountryCode.UY, 'UZ': CountryCode.UZ, 'VA': CountryCode.VA, 'VC': CountryCode.VC, 'VE': CountryCode.VE, 'VG': CountryCode.VG, 'VI': CountryCode.VI, 'VN': CountryCode.VN, 'VU': CountryCode.VU, 'WF': CountryCode.WF, 'WS': CountryCode.WS, 'YE': CountryCode.YE, 'YT': CountryCode.YT, 'ZA': CountryCode.ZA, 'ZM': CountryCode.ZM, 'ZW': CountryCode.ZW}

_member_names_ (kittycad.models.country_code.CountryCode attribute)

['AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AI', 'AQ', 'AG', 'AR', 'AM', 'AW', 'AU', 'AT', 'AZ', 'BS', 'BH', 'BD', 'BB', 'BY', 'BE', 'BZ', 'BJ', 'BM', 'BT', 'BO', 'BQ', 'BA', 'BW', 'BV', 'BR', 'IO', 'BN', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM', 'CA', 'KY', 'CF', 'TD', 'CL', 'CN', 'CX', 'CC', 'CO', 'KM', 'CG', 'CD', 'CK', 'CR', 'CI', 'HR', 'CU', 'CW', 'CY', 'CZ', 'DK', 'DJ', 'DM', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE', 'ET', 'FK', 'FO', 'FJ', 'FI', 'FR', 'GF', 'PF', 'TF', 'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GD', 'GP', 'GU', 'GT', 'GG', 'GN', 'GW', 'GY', 'HT', 'HM', 'VA', 'HN', 'HK', 'HU', 'IS', 'IN', 'ID', 'IR', 'IQ', 'IE', 'IM', 'IL', 'IT', 'JM', 'JP', 'JE', 'JO', 'KZ', 'KE', 'KI', 'KP', 'KR', 'KW', 'KG', 'LA', 'LV', 'LB', 'LS', 'LR', 'LY', 'LI', 'LT', 'LU', 'MO', 'MK', 'MG', 'MW', 'MY', 'MV', 'ML', 'MT', 'MH', 'MQ', 'MR', 'MU', 'YT', 'MX', 'FM', 'MD', 'MC', 'MN', 'ME', 'MS', 'MA', 'MZ', 'MM', 'NA', 'NR', 'NP', 'NL', 'NC', 'NZ', 'NI', 'NE', 'NG', 'NU', 'NF', 'MP', 'NO', 'OM', 'PK', 'PW', 'PS', 'PA', 'PG', 'PY', 'PE', 'PH', 'PN', 'PL', 'PT', 'PR', 'QA', 'RE', 'RO', 'RU', 'RW', 'BL', 'SH', 'KN', 'LC', 'MF', 'PM', 'VC', 'WS', 'SM', 'ST', 'SA', 'SN', 'RS', 'SC', 'SL', 'SG', 'SX', 'SK', 'SI', 'SB', 'SO', 'ZA', 'GS', 'SS', 'ES', 'LK', 'SD', 'SR', 'SJ', 'SZ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'TZ', 'TH', 'TL', 'TG', 'TK', 'TO', 'TT', 'TN', 'TR', 'TM', 'TC', 'TV', 'UG', 'UA', 'AE', 'GB', 'US', 'UM', 'UY', 'UZ', 'VU', 'VE', 'VN', 'VG', 'VI', 'WF', 'EH', 'YE', 'ZM', 'ZW']

_member_type_ (kittycad.models.country_code.CountryCode attribute)

_new_member_() (kittycad.models.country_code.CountryCode method)

_unhashable_values_ (kittycad.models.country_code.CountryCode attribute)

_value2member_map_ (kittycad.models.country_code.CountryCode attribute)

_value_repr_() (kittycad.models.country_code.CountryCode method)

isidentifier() (kittycad.models.country_code.CountryCode method)

maketrans() (kittycad.models.country_code.CountryCode static method)

removeprefix() (kittycad.models.country_code.CountryCode method)

removesuffix() (kittycad.models.country_code.CountryCode method)

:py:obj:`__init__ <kittycad.models.country_code.CountryCode.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.country_code.CountryCode.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.country_code.CountryCode.casefold>`\ \(\)

:py:obj:`center <kittycad.models.country_code.CountryCode.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.country_code.CountryCode.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.country_code.CountryCode.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.country_code.CountryCode.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.country_code.CountryCode.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.country_code.CountryCode.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.country_code.CountryCode.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.country_code.CountryCode.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.country_code.CountryCode.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.country_code.CountryCode.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.country_code.CountryCode.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.country_code.CountryCode.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.country_code.CountryCode.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.country_code.CountryCode.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.country_code.CountryCode.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.country_code.CountryCode.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.country_code.CountryCode.isupper>`\ \(\)

:py:obj:`join <kittycad.models.country_code.CountryCode.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.country_code.CountryCode.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.country_code.CountryCode.lower>`\ \(\)

:py:obj:`partition <kittycad.models.country_code.CountryCode.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.country_code.CountryCode.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.country_code.CountryCode.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.country_code.CountryCode.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.country_code.CountryCode.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.country_code.CountryCode.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.country_code.CountryCode.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.country_code.CountryCode.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.country_code.CountryCode.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.country_code.CountryCode.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.country_code.CountryCode.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.country_code.CountryCode.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.country_code.CountryCode.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.country_code.CountryCode.title>`\ \(\)

:py:obj:`translate <kittycad.models.country_code.CountryCode.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.country_code.CountryCode.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.country_code.CountryCode.zfill>`\ \(width\, \/\)

AF

# Åland Islands

AX

# Albania

AL

# Algeria

DZ

# American Samoa

AS

# Andorra

AD

# Angola

AO

# Anguilla

AI

# Antarctica

AQ

# Antigua and Barbuda

AG

# Argentina

AR

# Armenia

AM

# Aruba

AW

# Australia

AU

# Austria

AT

# Azerbaijan

AZ

# Bahamas

BS

# Bahrain

BH

# Bangladesh

BD

# Barbados

BB

# Belarus

BY

# Belgium

BE

# Belize

BZ

# Benin

BJ

# Bermuda

BM

# Bhutan

BT

# Bolivia (Plurinational State of)

BO

# Bonaire, Sint Eustatius and Saba

BQ

# Bosnia and Herzegovina

BA

# Botswana

BW

# Bouvet Island

BV

# Brazil

BR

# British Indian Ocean Territory

IO

# Brunei Darussalam

BN

# Bulgaria

BG

# Burkina Faso

BF

# Burundi

BI

# Cabo Verde

CV

# Cambodia

KH

# Cameroon

CM

# Canada

CA

# Cayman Islands

KY

# Central African Republic

CF

# Chad

TD

# Chile

CL

# China

CN

# Christmas Island

CX

# Cocos (Keeling) Islands

CC

# Colombia

CO

# Comoros

KM

# Congo

CG

# Congo (Democratic Republic of the)

CD

# Cook Islands

CK

# Costa Rica

CR

# Côte d'Ivoire

CI

# Croatia

HR

# Cuba

CU

# Curaçao

CW

# Cyprus

CY

# Czechia

CZ

# Denmark

DK

# Djibouti

DJ

# Dominica

DM

# Dominican Republic

DO

# Ecuador

EC

# Egypt

EG

# El Salvador

SV

# Equatorial Guinea

GQ

# Eritrea

ER

# Estonia

EE

# Ethiopia

ET

# Falkland Islands (Malvinas)

FK

# Faroe Islands

FO

# Fiji

FJ

# Finland

FI

# France

FR

# French Guiana

GF

# French Polynesia

PF

# French Southern Territories

TF

# Gabon

GA

# Gambia

GM

# Georgia

GE

# Germany

DE

# Ghana

GH

# Gibraltar

GI

# Greece

GR

# Greenland

GL

# Grenada

GD

# Guadeloupe

GP

# Guam

GU

# Guatemala

GT

# Guernsey

GG

# Guinea

GN

# Guinea-Bissau

GW

# Guyana

GY

# Haiti

HT

# Heard Island and McDonald Islands

HM

# Holy See

VA

# Honduras

HN

# Hong Kong

HK

# Hungary

HU

# Iceland

IS

# India

IN

# Indonesia

ID

# Iran (Islamic Republic of)

IR

# Iraq

IQ

# Ireland

IE

# Isle of Man

IM

# Israel

IL

# Italy

IT

# Jamaica

JM

# Japan

JP

# Jersey

JE

# Jordan

JO

# Kazakhstan

KZ

# Kenya

KE

# Kiribati

KI

# Korea (Democratic People's Republic of)

KP

# Korea (Republic of)

KR

# Kuwait

KW

# Kyrgyzstan

KG

# Lao People's Democratic Republic

LA

# Latvia

LV

# Lebanon

LB

# Lesotho

LS

# Liberia

LR

# Libya

LY

# Liechtenstein

LI

# Lithuania

LT

# Luxembourg

LU

# Macao

MO

# Macedonia (the former Yugoslav Republic of)

MK

# Madagascar

MG

# Malawi

MW

# Malaysia

MY

# Maldives

MV

# Mali

ML

# Malta

MT

# Marshall Islands

MH

# Martinique

MQ

# Mauritania

MR

# Mauritius

MU

# Mayotte

YT

# Mexico

MX

# Micronesia (Federated States of)

FM

# Moldova (Republic of)

MD

# Monaco

MC

# Mongolia

MN

# Montenegro

ME

# Montserrat

MS

# Morocco

MA

# Mozambique

MZ

# Myanmar

MM

# Namibia

NA

# Nauru

NR

# Nepal

NP

# Netherlands

NL

# New Caledonia

NC

# New Zealand

NZ

# Nicaragua

NI

# Niger

NE

# Nigeria

NG

# Niue

NU

# Norfolk Island

NF

# Northern Mariana Islands

MP

# Norway

NO

# Oman

OM

# Pakistan

PK

# Palau

PW

# Palestine, State of

PS

# Panama

PA

# Papua New Guinea

PG

# Paraguay

PY

# Peru

PE

# Philippines

PH

# Pitcairn

PN

# Poland

PL

# Portugal

PT

# Puerto Rico

PR

# Qatar

QA

# Réunion

RE

# Romania

RO

# Russian Federation

RU

# Rwanda

RW

# Saint Barthélemy

BL

# Saint Helena, Ascension and Tristan da Cunha

SH

# Saint Kitts and Nevis

KN

# Saint Lucia

LC

# Saint Martin (French part)

MF

# Saint Pierre and Miquelon

PM

# Saint Vincent and the Grenadines

VC

# Samoa

WS

# San Marino

SM

# Sao Tome and Principe

ST

# Saudi Arabia

SA

# Senegal

SN

# Serbia

RS

# Seychelles

SC

# Sierra Leone

SL

# Singapore

SG

# Sint Maarten (Dutch part)

SX

# Slovakia

SK

# Slovenia

SI

# Solomon Islands

SB

# Somalia

SO

# South Africa

ZA

# South Georgia and the South Sandwich Islands

GS

# South Sudan

SS

# Spain

ES

# Sri Lanka

LK

# Sudan

SD

# Suriname

SR

# Svalbard and Jan Mayen

SJ

# Swaziland

SZ

# Sweden

SE

# Switzerland

CH

# Syrian Arab Republic

SY

# Taiwan, Province of China

TW

# Tajikistan

TJ

# Tanzania, United Republic of

TZ

# Thailand

TH

# Timor-Leste

TL

# Togo

TG

# Tokelau

TK

# Tonga

TO

# Trinidad and Tobago

TT

# Tunisia

TN

# Turkey

TR

# Turkmenistan

TM

# Turks and Caicos Islands

TC

# Tuvalu

TV

# Uganda

UG

# Ukraine

UA

# United Arab Emirates

AE

# United Kingdom of Great Britain and Northern Ireland

GB

# United States of America

US

# United States Minor Outlying Islands

UM

# Uruguay

UY

# Uzbekistan

UZ

# Vanuatu

VU

# Venezuela (Bolivarian Republic of)

VE

# Viet Nam

VN

# Virgin Islands (British)

VG

# Virgin Islands (U.S.)

VI

# Wallis and Futuna

WF

# Western Sahara

EH

# Yemen

YE

# Zambia

ZM

# Zimbabwe

ZW

Coupon([amount_off, deleted, id, percent_off])

The resource representing a Coupon.

:py:obj:`Coupon <kittycad.models.coupon.Coupon>`\ \(\[amount\_off\, deleted\, id\, percent\_off\]\)

Coupon(amount_off=<kittycad.types.Unset object>, deleted=False, id=<kittycad.types.Unset object>, percent_off=<kittycad.types.Unset object>)

(amount_off=<kittycad.types.Unset object>, deleted=False, id=<kittycad.types.Unset object>, percent_off=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'amount_off': typing.Union[kittycad.types.Unset, float], 'deleted': typing.Union[kittycad.types.Unset, bool], 'id': typing.Union[kittycad.types.Unset, str], 'percent_off': typing.Union[kittycad.types.Unset, float]}

(Attribute(name='amount_off', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_off'), Attribute(name='deleted', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='deleted'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='percent_off', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='percent_off'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.coupon', '__annotations__': {'amount_off': typing.Union[kittycad.types.Unset, float], 'deleted': typing.Union[kittycad.types.Unset, bool], 'id': typing.Union[kittycad.types.Unset, str], 'percent_off': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The resource representing a Coupon.', 'to_dict': <function Coupon.to_dict>, 'from_dict': <classmethod(<function Coupon.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Coupon.__getitem__>, '__setitem__': <function Coupon.__setitem__>, '__delitem__': <function Coupon.__delitem__>, '__contains__': <function Coupon.__contains__>, '__dict__': <attribute '__dict__' of 'Coupon' objects>, '__weakref__': <attribute '__weakref__' of 'Coupon' objects>, '__attrs_attrs__': (Attribute(name='amount_off', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_off'), Attribute(name='deleted', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='deleted'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='percent_off', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='percent_off'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Coupon.__repr__>, '__eq__': <function Coupon.__eq__>, '__ne__': <function Coupon.__ne__>, '__lt__': <function Coupon.__lt__>, '__le__': <function Coupon.__le__>, '__gt__': <function Coupon.__gt__>, '__ge__': <function Coupon.__ge__>, '__hash__': None, '__init__': <function Coupon.__init__>, '__match_args__': ('amount_off', 'deleted', 'id', 'percent_off')})

Coupon.__init__(amount_off=<kittycad.types.Unset object>, deleted=False, id=<kittycad.types.Unset object>, percent_off=<kittycad.types.Unset object>)

__init__([amount_off, deleted, id, percent_off])

Method generated by attrs for class Coupon.

rtype

TypeVar(PC, bound= Coupon)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.coupon.Coupon.__init__>`\ \(\[amount\_off\, deleted\, id\, percent\_off\]\)

:py:obj:`from_dict <kittycad.models.coupon.Coupon.from_dict>`\ \(src\_dict\)

amount_off

deleted

id

percent_off

CreatedAtSortMode(value[, names, module, ...])

Supported set of sort modes for scanning by created_at only.

:py:obj:`CreatedAtSortMode <kittycad.models.created_at_sort_mode.CreatedAtSortMode>`\ \(value\[\, names\, module\, ...\]\)

CreatedAtSortMode (class in kittycad.models.created_at_sort_mode)

CreatedAtSortMode(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__add__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__contains__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__dict__ (kittycad.models.created_at_sort_mode.CreatedAtSortMode attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.created_at_sort_mode', '__doc__': 'Supported set of sort modes for scanning by created_at only.\n\n    Currently, we only support scanning in ascending order.', '__str__': <function CreatedAtSortMode.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CREATED_AT_ASCENDING', 'CREATED_AT_DESCENDING'], '_member_map_': {'CREATED_AT_ASCENDING': <CreatedAtSortMode.CREATED_AT_ASCENDING: 'created-at-ascending'>, 'CREATED_AT_DESCENDING': <CreatedAtSortMode.CREATED_AT_DESCENDING: 'created-at-descending'>}, '_value2member_map_': {'created-at-ascending': <CreatedAtSortMode.CREATED_AT_ASCENDING: 'created-at-ascending'>, 'created-at-descending': <CreatedAtSortMode.CREATED_AT_DESCENDING: 'created-at-descending'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'CreatedAtSortMode' objects>, '__weakref__': <attribute '__weakref__' of 'CreatedAtSortMode' objects>, 'CREATED_AT_ASCENDING': <CreatedAtSortMode.CREATED_AT_ASCENDING: 'created-at-ascending'>, 'CREATED_AT_DESCENDING': <CreatedAtSortMode.CREATED_AT_DESCENDING: 'created-at-descending'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__eq__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__format__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__ge__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__getitem__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__getnewargs__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__gt__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__hash__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__init__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__iter__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__le__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__len__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__lt__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__mod__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__module__ (kittycad.models.created_at_sort_mode.CreatedAtSortMode attribute)

__mul__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__ne__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__new__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__reduce_ex__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__repr__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__rmod__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__rmul__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__sizeof__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

__str__() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

CreatedAtSortMode._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.created_at_sort_mode.CreatedAtSortMode attribute)

_member_type_ (kittycad.models.created_at_sort_mode.CreatedAtSortMode attribute)

_new_member_() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

_use_args_ (kittycad.models.created_at_sort_mode.CreatedAtSortMode attribute)

_value_repr_() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

capitalize() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

casefold() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

center() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

count() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

encode() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

endswith() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

expandtabs() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

find() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

format() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

format_map() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

index() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isalnum() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isalpha() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isascii() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isdecimal() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isdigit() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isidentifier() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

islower() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isnumeric() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isprintable() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isspace() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

istitle() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

isupper() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

join() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

ljust() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

lower() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

lstrip() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

maketrans() (kittycad.models.created_at_sort_mode.CreatedAtSortMode static method)

partition() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

removeprefix() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

removesuffix() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

replace() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rfind() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rindex() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rjust() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rpartition() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rsplit() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

rstrip() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

split() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

splitlines() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

startswith() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

strip() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

swapcase() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

title() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

translate() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

upper() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

zfill() (kittycad.models.created_at_sort_mode.CreatedAtSortMode method)

:py:obj:`__init__ <kittycad.models.created_at_sort_mode.CreatedAtSortMode.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.created_at_sort_mode.CreatedAtSortMode.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.created_at_sort_mode.CreatedAtSortMode.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.created_at_sort_mode.CreatedAtSortMode.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.created_at_sort_mode.CreatedAtSortMode.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.created_at_sort_mode.CreatedAtSortMode.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.created_at_sort_mode.CreatedAtSortMode.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.created_at_sort_mode.CreatedAtSortMode.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.created_at_sort_mode.CreatedAtSortMode.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.created_at_sort_mode.CreatedAtSortMode.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.created_at_sort_mode.CreatedAtSortMode.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.created_at_sort_mode.CreatedAtSortMode.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.created_at_sort_mode.CreatedAtSortMode.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.created_at_sort_mode.CreatedAtSortMode.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.created_at_sort_mode.CreatedAtSortMode.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.created_at_sort_mode.CreatedAtSortMode.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.created_at_sort_mode.CreatedAtSortMode.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.created_at_sort_mode.CreatedAtSortMode.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.created_at_sort_mode.CreatedAtSortMode.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.created_at_sort_mode.CreatedAtSortMode.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.created_at_sort_mode.CreatedAtSortMode.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.created_at_sort_mode.CreatedAtSortMode.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.created_at_sort_mode.CreatedAtSortMode.zfill>`\ \(width\, \/\)

CREATED_AT_ASCENDING

# sort in decreasing order of "created_at"

CREATED_AT_DESCENDING

Currency(value[, names, module, qualname, ...])

Currency is the list of supported currencies.

:py:obj:`Currency <kittycad.models.currency.Currency>`\ \(value\[\, names\, module\, qualname\, ...\]\)

Currency(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

This comes from the Stripe API docs: For more details see <https://support.stripe.com/questions/which-currencies-does-stripe-support>.

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.currency', '__doc__': 'Currency is the list of supported currencies.\n\n    This comes from the Stripe API docs: For more details see <https://support.stripe.com/questions/which-currencies-does-stripe-support>.\n    ', '__str__': <function Currency.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['AED', 'AFN', 'ALL', 'AMD', 'ANG', 'AOA', 'ARS', 'AUD', 'AWG', 'AZN', 'BAM', 'BBD', 'BDT', 'BGN', 'BIF', 'BMD', 'BND', 'BOB', 'BRL', 'BSD', 'BWP', 'BZD', 'CAD', 'CDF', 'CHF', 'CLP', 'CNY', 'COP', 'CRC', 'CVE', 'CZK', 'DJF', 'DKK', 'DOP', 'DZD', 'EEK', 'EGP', 'ETB', 'EUR', 'FJD', 'FKP', 'GBP', 'GEL', 'GIP', 'GMD', 'GNF', 'GTQ', 'GYD', 'HKD', 'HNL', 'HRK', 'HTG', 'HUF', 'IDR', 'ILS', 'INR', 'ISK', 'JMD', 'JPY', 'KES', 'KGS', 'KHR', 'KMF', 'KRW', 'KYD', 'KZT', 'LAK', 'LBP', 'LKR', 'LRD', 'LSL', 'LTL', 'LVL', 'MAD', 'MDL', 'MGA', 'MKD', 'MNT', 'MOP', 'MRO', 'MUR', 'MVR', 'MWK', 'MXN', 'MYR', 'MZN', 'NAD', 'NGN', 'NIO', 'NOK', 'NPR', 'NZD', 'PAB', 'PEN', 'PGK', 'PHP', 'PKR', 'PLN', 'PYG', 'QAR', 'RON', 'RSD', 'RUB', 'RWF', 'SAR', 'SBD', 'SCR', 'SEK', 'SGD', 'SHP', 'SLL', 'SOS', 'SRD', 'STD', 'SVC', 'SZL', 'THB', 'TJS', 'TOP', 'TRY', 'TTD', 'TWD', 'TZS', 'UAH', 'UGX', 'USD', 'UYU', 'UZS', 'VEF', 'VND', 'VUV', 'WST', 'XAF', 'XCD', 'XOF', 'XPF', 'YER', 'ZAR', 'ZMW'], '_member_map_': {'AED': <Currency.AED: 'aed'>, 'AFN': <Currency.AFN: 'afn'>, 'ALL': <Currency.ALL: 'all'>, 'AMD': <Currency.AMD: 'amd'>, 'ANG': <Currency.ANG: 'ang'>, 'AOA': <Currency.AOA: 'aoa'>, 'ARS': <Currency.ARS: 'ars'>, 'AUD': <Currency.AUD: 'aud'>, 'AWG': <Currency.AWG: 'awg'>, 'AZN': <Currency.AZN: 'azn'>, 'BAM': <Currency.BAM: 'bam'>, 'BBD': <Currency.BBD: 'bbd'>, 'BDT': <Currency.BDT: 'bdt'>, 'BGN': <Currency.BGN: 'bgn'>, 'BIF': <Currency.BIF: 'bif'>, 'BMD': <Currency.BMD: 'bmd'>, 'BND': <Currency.BND: 'bnd'>, 'BOB': <Currency.BOB: 'bob'>, 'BRL': <Currency.BRL: 'brl'>, 'BSD': <Currency.BSD: 'bsd'>, 'BWP': <Currency.BWP: 'bwp'>, 'BZD': <Currency.BZD: 'bzd'>, 'CAD': <Currency.CAD: 'cad'>, 'CDF': <Currency.CDF: 'cdf'>, 'CHF': <Currency.CHF: 'chf'>, 'CLP': <Currency.CLP: 'clp'>, 'CNY': <Currency.CNY: 'cny'>, 'COP': <Currency.COP: 'cop'>, 'CRC': <Currency.CRC: 'crc'>, 'CVE': <Currency.CVE: 'cve'>, 'CZK': <Currency.CZK: 'czk'>, 'DJF': <Currency.DJF: 'djf'>, 'DKK': <Currency.DKK: 'dkk'>, 'DOP': <Currency.DOP: 'dop'>, 'DZD': <Currency.DZD: 'dzd'>, 'EEK': <Currency.EEK: 'eek'>, 'EGP': <Currency.EGP: 'egp'>, 'ETB': <Currency.ETB: 'etb'>, 'EUR': <Currency.EUR: 'eur'>, 'FJD': <Currency.FJD: 'fjd'>, 'FKP': <Currency.FKP: 'fkp'>, 'GBP': <Currency.GBP: 'gbp'>, 'GEL': <Currency.GEL: 'gel'>, 'GIP': <Currency.GIP: 'gip'>, 'GMD': <Currency.GMD: 'gmd'>, 'GNF': <Currency.GNF: 'gnf'>, 'GTQ': <Currency.GTQ: 'gtq'>, 'GYD': <Currency.GYD: 'gyd'>, 'HKD': <Currency.HKD: 'hkd'>, 'HNL': <Currency.HNL: 'hnl'>, 'HRK': <Currency.HRK: 'hrk'>, 'HTG': <Currency.HTG: 'htg'>, 'HUF': <Currency.HUF: 'huf'>, 'IDR': <Currency.IDR: 'idr'>, 'ILS': <Currency.ILS: 'ils'>, 'INR': <Currency.INR: 'inr'>, 'ISK': <Currency.ISK: 'isk'>, 'JMD': <Currency.JMD: 'jmd'>, 'JPY': <Currency.JPY: 'jpy'>, 'KES': <Currency.KES: 'kes'>, 'KGS': <Currency.KGS: 'kgs'>, 'KHR': <Currency.KHR: 'khr'>, 'KMF': <Currency.KMF: 'kmf'>, 'KRW': <Currency.KRW: 'krw'>, 'KYD': <Currency.KYD: 'kyd'>, 'KZT': <Currency.KZT: 'kzt'>, 'LAK': <Currency.LAK: 'lak'>, 'LBP': <Currency.LBP: 'lbp'>, 'LKR': <Currency.LKR: 'lkr'>, 'LRD': <Currency.LRD: 'lrd'>, 'LSL': <Currency.LSL: 'lsl'>, 'LTL': <Currency.LTL: 'ltl'>, 'LVL': <Currency.LVL: 'lvl'>, 'MAD': <Currency.MAD: 'mad'>, 'MDL': <Currency.MDL: 'mdl'>, 'MGA': <Currency.MGA: 'mga'>, 'MKD': <Currency.MKD: 'mkd'>, 'MNT': <Currency.MNT: 'mnt'>, 'MOP': <Currency.MOP: 'mop'>, 'MRO': <Currency.MRO: 'mro'>, 'MUR': <Currency.MUR: 'mur'>, 'MVR': <Currency.MVR: 'mvr'>, 'MWK': <Currency.MWK: 'mwk'>, 'MXN': <Currency.MXN: 'mxn'>, 'MYR': <Currency.MYR: 'myr'>, 'MZN': <Currency.MZN: 'mzn'>, 'NAD': <Currency.NAD: 'nad'>, 'NGN': <Currency.NGN: 'ngn'>, 'NIO': <Currency.NIO: 'nio'>, 'NOK': <Currency.NOK: 'nok'>, 'NPR': <Currency.NPR: 'npr'>, 'NZD': <Currency.NZD: 'nzd'>, 'PAB': <Currency.PAB: 'pab'>, 'PEN': <Currency.PEN: 'pen'>, 'PGK': <Currency.PGK: 'pgk'>, 'PHP': <Currency.PHP: 'php'>, 'PKR': <Currency.PKR: 'pkr'>, 'PLN': <Currency.PLN: 'pln'>, 'PYG': <Currency.PYG: 'pyg'>, 'QAR': <Currency.QAR: 'qar'>, 'RON': <Currency.RON: 'ron'>, 'RSD': <Currency.RSD: 'rsd'>, 'RUB': <Currency.RUB: 'rub'>, 'RWF': <Currency.RWF: 'rwf'>, 'SAR': <Currency.SAR: 'sar'>, 'SBD': <Currency.SBD: 'sbd'>, 'SCR': <Currency.SCR: 'scr'>, 'SEK': <Currency.SEK: 'sek'>, 'SGD': <Currency.SGD: 'sgd'>, 'SHP': <Currency.SHP: 'shp'>, 'SLL': <Currency.SLL: 'sll'>, 'SOS': <Currency.SOS: 'sos'>, 'SRD': <Currency.SRD: 'srd'>, 'STD': <Currency.STD: 'std'>, 'SVC': <Currency.SVC: 'svc'>, 'SZL': <Currency.SZL: 'szl'>, 'THB': <Currency.THB: 'thb'>, 'TJS': <Currency.TJS: 'tjs'>, 'TOP': <Currency.TOP: 'top'>, 'TRY': <Currency.TRY: 'try'>, 'TTD': <Currency.TTD: 'ttd'>, 'TWD': <Currency.TWD: 'twd'>, 'TZS': <Currency.TZS: 'tzs'>, 'UAH': <Currency.UAH: 'uah'>, 'UGX': <Currency.UGX: 'ugx'>, 'USD': <Currency.USD: 'usd'>, 'UYU': <Currency.UYU: 'uyu'>, 'UZS': <Currency.UZS: 'uzs'>, 'VEF': <Currency.VEF: 'vef'>, 'VND': <Currency.VND: 'vnd'>, 'VUV': <Currency.VUV: 'vuv'>, 'WST': <Currency.WST: 'wst'>, 'XAF': <Currency.XAF: 'xaf'>, 'XCD': <Currency.XCD: 'xcd'>, 'XOF': <Currency.XOF: 'xof'>, 'XPF': <Currency.XPF: 'xpf'>, 'YER': <Currency.YER: 'yer'>, 'ZAR': <Currency.ZAR: 'zar'>, 'ZMW': <Currency.ZMW: 'zmw'>}, '_value2member_map_': {'aed': <Currency.AED: 'aed'>, 'afn': <Currency.AFN: 'afn'>, 'all': <Currency.ALL: 'all'>, 'amd': <Currency.AMD: 'amd'>, 'ang': <Currency.ANG: 'ang'>, 'aoa': <Currency.AOA: 'aoa'>, 'ars': <Currency.ARS: 'ars'>, 'aud': <Currency.AUD: 'aud'>, 'awg': <Currency.AWG: 'awg'>, 'azn': <Currency.AZN: 'azn'>, 'bam': <Currency.BAM: 'bam'>, 'bbd': <Currency.BBD: 'bbd'>, 'bdt': <Currency.BDT: 'bdt'>, 'bgn': <Currency.BGN: 'bgn'>, 'bif': <Currency.BIF: 'bif'>, 'bmd': <Currency.BMD: 'bmd'>, 'bnd': <Currency.BND: 'bnd'>, 'bob': <Currency.BOB: 'bob'>, 'brl': <Currency.BRL: 'brl'>, 'bsd': <Currency.BSD: 'bsd'>, 'bwp': <Currency.BWP: 'bwp'>, 'bzd': <Currency.BZD: 'bzd'>, 'cad': <Currency.CAD: 'cad'>, 'cdf': <Currency.CDF: 'cdf'>, 'chf': <Currency.CHF: 'chf'>, 'clp': <Currency.CLP: 'clp'>, 'cny': <Currency.CNY: 'cny'>, 'cop': <Currency.COP: 'cop'>, 'crc': <Currency.CRC: 'crc'>, 'cve': <Currency.CVE: 'cve'>, 'czk': <Currency.CZK: 'czk'>, 'djf': <Currency.DJF: 'djf'>, 'dkk': <Currency.DKK: 'dkk'>, 'dop': <Currency.DOP: 'dop'>, 'dzd': <Currency.DZD: 'dzd'>, 'eek': <Currency.EEK: 'eek'>, 'egp': <Currency.EGP: 'egp'>, 'etb': <Currency.ETB: 'etb'>, 'eur': <Currency.EUR: 'eur'>, 'fjd': <Currency.FJD: 'fjd'>, 'fkp': <Currency.FKP: 'fkp'>, 'gbp': <Currency.GBP: 'gbp'>, 'gel': <Currency.GEL: 'gel'>, 'gip': <Currency.GIP: 'gip'>, 'gmd': <Currency.GMD: 'gmd'>, 'gnf': <Currency.GNF: 'gnf'>, 'gtq': <Currency.GTQ: 'gtq'>, 'gyd': <Currency.GYD: 'gyd'>, 'hkd': <Currency.HKD: 'hkd'>, 'hnl': <Currency.HNL: 'hnl'>, 'hrk': <Currency.HRK: 'hrk'>, 'htg': <Currency.HTG: 'htg'>, 'huf': <Currency.HUF: 'huf'>, 'idr': <Currency.IDR: 'idr'>, 'ils': <Currency.ILS: 'ils'>, 'inr': <Currency.INR: 'inr'>, 'isk': <Currency.ISK: 'isk'>, 'jmd': <Currency.JMD: 'jmd'>, 'jpy': <Currency.JPY: 'jpy'>, 'kes': <Currency.KES: 'kes'>, 'kgs': <Currency.KGS: 'kgs'>, 'khr': <Currency.KHR: 'khr'>, 'kmf': <Currency.KMF: 'kmf'>, 'krw': <Currency.KRW: 'krw'>, 'kyd': <Currency.KYD: 'kyd'>, 'kzt': <Currency.KZT: 'kzt'>, 'lak': <Currency.LAK: 'lak'>, 'lbp': <Currency.LBP: 'lbp'>, 'lkr': <Currency.LKR: 'lkr'>, 'lrd': <Currency.LRD: 'lrd'>, 'lsl': <Currency.LSL: 'lsl'>, 'ltl': <Currency.LTL: 'ltl'>, 'lvl': <Currency.LVL: 'lvl'>, 'mad': <Currency.MAD: 'mad'>, 'mdl': <Currency.MDL: 'mdl'>, 'mga': <Currency.MGA: 'mga'>, 'mkd': <Currency.MKD: 'mkd'>, 'mnt': <Currency.MNT: 'mnt'>, 'mop': <Currency.MOP: 'mop'>, 'mro': <Currency.MRO: 'mro'>, 'mur': <Currency.MUR: 'mur'>, 'mvr': <Currency.MVR: 'mvr'>, 'mwk': <Currency.MWK: 'mwk'>, 'mxn': <Currency.MXN: 'mxn'>, 'myr': <Currency.MYR: 'myr'>, 'mzn': <Currency.MZN: 'mzn'>, 'nad': <Currency.NAD: 'nad'>, 'ngn': <Currency.NGN: 'ngn'>, 'nio': <Currency.NIO: 'nio'>, 'nok': <Currency.NOK: 'nok'>, 'npr': <Currency.NPR: 'npr'>, 'nzd': <Currency.NZD: 'nzd'>, 'pab': <Currency.PAB: 'pab'>, 'pen': <Currency.PEN: 'pen'>, 'pgk': <Currency.PGK: 'pgk'>, 'php': <Currency.PHP: 'php'>, 'pkr': <Currency.PKR: 'pkr'>, 'pln': <Currency.PLN: 'pln'>, 'pyg': <Currency.PYG: 'pyg'>, 'qar': <Currency.QAR: 'qar'>, 'ron': <Currency.RON: 'ron'>, 'rsd': <Currency.RSD: 'rsd'>, 'rub': <Currency.RUB: 'rub'>, 'rwf': <Currency.RWF: 'rwf'>, 'sar': <Currency.SAR: 'sar'>, 'sbd': <Currency.SBD: 'sbd'>, 'scr': <Currency.SCR: 'scr'>, 'sek': <Currency.SEK: 'sek'>, 'sgd': <Currency.SGD: 'sgd'>, 'shp': <Currency.SHP: 'shp'>, 'sll': <Currency.SLL: 'sll'>, 'sos': <Currency.SOS: 'sos'>, 'srd': <Currency.SRD: 'srd'>, 'std': <Currency.STD: 'std'>, 'svc': <Currency.SVC: 'svc'>, 'szl': <Currency.SZL: 'szl'>, 'thb': <Currency.THB: 'thb'>, 'tjs': <Currency.TJS: 'tjs'>, 'top': <Currency.TOP: 'top'>, 'try': <Currency.TRY: 'try'>, 'ttd': <Currency.TTD: 'ttd'>, 'twd': <Currency.TWD: 'twd'>, 'tzs': <Currency.TZS: 'tzs'>, 'uah': <Currency.UAH: 'uah'>, 'ugx': <Currency.UGX: 'ugx'>, 'usd': <Currency.USD: 'usd'>, 'uyu': <Currency.UYU: 'uyu'>, 'uzs': <Currency.UZS: 'uzs'>, 'vef': <Currency.VEF: 'vef'>, 'vnd': <Currency.VND: 'vnd'>, 'vuv': <Currency.VUV: 'vuv'>, 'wst': <Currency.WST: 'wst'>, 'xaf': <Currency.XAF: 'xaf'>, 'xcd': <Currency.XCD: 'xcd'>, 'xof': <Currency.XOF: 'xof'>, 'xpf': <Currency.XPF: 'xpf'>, 'yer': <Currency.YER: 'yer'>, 'zar': <Currency.ZAR: 'zar'>, 'zmw': <Currency.ZMW: 'zmw'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Currency' objects>, '__weakref__': <attribute '__weakref__' of 'Currency' objects>, 'AED': <Currency.AED: 'aed'>, 'AFN': <Currency.AFN: 'afn'>, 'ALL': <Currency.ALL: 'all'>, 'AMD': <Currency.AMD: 'amd'>, 'ANG': <Currency.ANG: 'ang'>, 'AOA': <Currency.AOA: 'aoa'>, 'ARS': <Currency.ARS: 'ars'>, 'AUD': <Currency.AUD: 'aud'>, 'AWG': <Currency.AWG: 'awg'>, 'AZN': <Currency.AZN: 'azn'>, 'BAM': <Currency.BAM: 'bam'>, 'BBD': <Currency.BBD: 'bbd'>, 'BDT': <Currency.BDT: 'bdt'>, 'BGN': <Currency.BGN: 'bgn'>, 'BIF': <Currency.BIF: 'bif'>, 'BMD': <Currency.BMD: 'bmd'>, 'BND': <Currency.BND: 'bnd'>, 'BOB': <Currency.BOB: 'bob'>, 'BRL': <Currency.BRL: 'brl'>, 'BSD': <Currency.BSD: 'bsd'>, 'BWP': <Currency.BWP: 'bwp'>, 'BZD': <Currency.BZD: 'bzd'>, 'CAD': <Currency.CAD: 'cad'>, 'CDF': <Currency.CDF: 'cdf'>, 'CHF': <Currency.CHF: 'chf'>, 'CLP': <Currency.CLP: 'clp'>, 'CNY': <Currency.CNY: 'cny'>, 'COP': <Currency.COP: 'cop'>, 'CRC': <Currency.CRC: 'crc'>, 'CVE': <Currency.CVE: 'cve'>, 'CZK': <Currency.CZK: 'czk'>, 'DJF': <Currency.DJF: 'djf'>, 'DKK': <Currency.DKK: 'dkk'>, 'DOP': <Currency.DOP: 'dop'>, 'DZD': <Currency.DZD: 'dzd'>, 'EEK': <Currency.EEK: 'eek'>, 'EGP': <Currency.EGP: 'egp'>, 'ETB': <Currency.ETB: 'etb'>, 'EUR': <Currency.EUR: 'eur'>, 'FJD': <Currency.FJD: 'fjd'>, 'FKP': <Currency.FKP: 'fkp'>, 'GBP': <Currency.GBP: 'gbp'>, 'GEL': <Currency.GEL: 'gel'>, 'GIP': <Currency.GIP: 'gip'>, 'GMD': <Currency.GMD: 'gmd'>, 'GNF': <Currency.GNF: 'gnf'>, 'GTQ': <Currency.GTQ: 'gtq'>, 'GYD': <Currency.GYD: 'gyd'>, 'HKD': <Currency.HKD: 'hkd'>, 'HNL': <Currency.HNL: 'hnl'>, 'HRK': <Currency.HRK: 'hrk'>, 'HTG': <Currency.HTG: 'htg'>, 'HUF': <Currency.HUF: 'huf'>, 'IDR': <Currency.IDR: 'idr'>, 'ILS': <Currency.ILS: 'ils'>, 'INR': <Currency.INR: 'inr'>, 'ISK': <Currency.ISK: 'isk'>, 'JMD': <Currency.JMD: 'jmd'>, 'JPY': <Currency.JPY: 'jpy'>, 'KES': <Currency.KES: 'kes'>, 'KGS': <Currency.KGS: 'kgs'>, 'KHR': <Currency.KHR: 'khr'>, 'KMF': <Currency.KMF: 'kmf'>, 'KRW': <Currency.KRW: 'krw'>, 'KYD': <Currency.KYD: 'kyd'>, 'KZT': <Currency.KZT: 'kzt'>, 'LAK': <Currency.LAK: 'lak'>, 'LBP': <Currency.LBP: 'lbp'>, 'LKR': <Currency.LKR: 'lkr'>, 'LRD': <Currency.LRD: 'lrd'>, 'LSL': <Currency.LSL: 'lsl'>, 'LTL': <Currency.LTL: 'ltl'>, 'LVL': <Currency.LVL: 'lvl'>, 'MAD': <Currency.MAD: 'mad'>, 'MDL': <Currency.MDL: 'mdl'>, 'MGA': <Currency.MGA: 'mga'>, 'MKD': <Currency.MKD: 'mkd'>, 'MNT': <Currency.MNT: 'mnt'>, 'MOP': <Currency.MOP: 'mop'>, 'MRO': <Currency.MRO: 'mro'>, 'MUR': <Currency.MUR: 'mur'>, 'MVR': <Currency.MVR: 'mvr'>, 'MWK': <Currency.MWK: 'mwk'>, 'MXN': <Currency.MXN: 'mxn'>, 'MYR': <Currency.MYR: 'myr'>, 'MZN': <Currency.MZN: 'mzn'>, 'NAD': <Currency.NAD: 'nad'>, 'NGN': <Currency.NGN: 'ngn'>, 'NIO': <Currency.NIO: 'nio'>, 'NOK': <Currency.NOK: 'nok'>, 'NPR': <Currency.NPR: 'npr'>, 'NZD': <Currency.NZD: 'nzd'>, 'PAB': <Currency.PAB: 'pab'>, 'PEN': <Currency.PEN: 'pen'>, 'PGK': <Currency.PGK: 'pgk'>, 'PHP': <Currency.PHP: 'php'>, 'PKR': <Currency.PKR: 'pkr'>, 'PLN': <Currency.PLN: 'pln'>, 'PYG': <Currency.PYG: 'pyg'>, 'QAR': <Currency.QAR: 'qar'>, 'RON': <Currency.RON: 'ron'>, 'RSD': <Currency.RSD: 'rsd'>, 'RUB': <Currency.RUB: 'rub'>, 'RWF': <Currency.RWF: 'rwf'>, 'SAR': <Currency.SAR: 'sar'>, 'SBD': <Currency.SBD: 'sbd'>, 'SCR': <Currency.SCR: 'scr'>, 'SEK': <Currency.SEK: 'sek'>, 'SGD': <Currency.SGD: 'sgd'>, 'SHP': <Currency.SHP: 'shp'>, 'SLL': <Currency.SLL: 'sll'>, 'SOS': <Currency.SOS: 'sos'>, 'SRD': <Currency.SRD: 'srd'>, 'STD': <Currency.STD: 'std'>, 'SVC': <Currency.SVC: 'svc'>, 'SZL': <Currency.SZL: 'szl'>, 'THB': <Currency.THB: 'thb'>, 'TJS': <Currency.TJS: 'tjs'>, 'TOP': <Currency.TOP: 'top'>, 'TRY': <Currency.TRY: 'try'>, 'TTD': <Currency.TTD: 'ttd'>, 'TWD': <Currency.TWD: 'twd'>, 'TZS': <Currency.TZS: 'tzs'>, 'UAH': <Currency.UAH: 'uah'>, 'UGX': <Currency.UGX: 'ugx'>, 'USD': <Currency.USD: 'usd'>, 'UYU': <Currency.UYU: 'uyu'>, 'UZS': <Currency.UZS: 'uzs'>, 'VEF': <Currency.VEF: 'vef'>, 'VND': <Currency.VND: 'vnd'>, 'VUV': <Currency.VUV: 'vuv'>, 'WST': <Currency.WST: 'wst'>, 'XAF': <Currency.XAF: 'xaf'>, 'XCD': <Currency.XCD: 'xcd'>, 'XOF': <Currency.XOF: 'xof'>, 'XPF': <Currency.XPF: 'xpf'>, 'YER': <Currency.YER: 'yer'>, 'ZAR': <Currency.ZAR: 'zar'>, 'ZMW': <Currency.ZMW: 'zmw'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

_generate_next_value_() (kittycad.models.currency.Currency method)

{'AED': Currency.AED, 'AFN': Currency.AFN, 'ALL': Currency.ALL, 'AMD': Currency.AMD, 'ANG': Currency.ANG, 'AOA': Currency.AOA, 'ARS': Currency.ARS, 'AUD': Currency.AUD, 'AWG': Currency.AWG, 'AZN': Currency.AZN, 'BAM': Currency.BAM, 'BBD': Currency.BBD, 'BDT': Currency.BDT, 'BGN': Currency.BGN, 'BIF': Currency.BIF, 'BMD': Currency.BMD, 'BND': Currency.BND, 'BOB': Currency.BOB, 'BRL': Currency.BRL, 'BSD': Currency.BSD, 'BWP': Currency.BWP, 'BZD': Currency.BZD, 'CAD': Currency.CAD, 'CDF': Currency.CDF, 'CHF': Currency.CHF, 'CLP': Currency.CLP, 'CNY': Currency.CNY, 'COP': Currency.COP, 'CRC': Currency.CRC, 'CVE': Currency.CVE, 'CZK': Currency.CZK, 'DJF': Currency.DJF, 'DKK': Currency.DKK, 'DOP': Currency.DOP, 'DZD': Currency.DZD, 'EEK': Currency.EEK, 'EGP': Currency.EGP, 'ETB': Currency.ETB, 'EUR': Currency.EUR, 'FJD': Currency.FJD, 'FKP': Currency.FKP, 'GBP': Currency.GBP, 'GEL': Currency.GEL, 'GIP': Currency.GIP, 'GMD': Currency.GMD, 'GNF': Currency.GNF, 'GTQ': Currency.GTQ, 'GYD': Currency.GYD, 'HKD': Currency.HKD, 'HNL': Currency.HNL, 'HRK': Currency.HRK, 'HTG': Currency.HTG, 'HUF': Currency.HUF, 'IDR': Currency.IDR, 'ILS': Currency.ILS, 'INR': Currency.INR, 'ISK': Currency.ISK, 'JMD': Currency.JMD, 'JPY': Currency.JPY, 'KES': Currency.KES, 'KGS': Currency.KGS, 'KHR': Currency.KHR, 'KMF': Currency.KMF, 'KRW': Currency.KRW, 'KYD': Currency.KYD, 'KZT': Currency.KZT, 'LAK': Currency.LAK, 'LBP': Currency.LBP, 'LKR': Currency.LKR, 'LRD': Currency.LRD, 'LSL': Currency.LSL, 'LTL': Currency.LTL, 'LVL': Currency.LVL, 'MAD': Currency.MAD, 'MDL': Currency.MDL, 'MGA': Currency.MGA, 'MKD': Currency.MKD, 'MNT': Currency.MNT, 'MOP': Currency.MOP, 'MRO': Currency.MRO, 'MUR': Currency.MUR, 'MVR': Currency.MVR, 'MWK': Currency.MWK, 'MXN': Currency.MXN, 'MYR': Currency.MYR, 'MZN': Currency.MZN, 'NAD': Currency.NAD, 'NGN': Currency.NGN, 'NIO': Currency.NIO, 'NOK': Currency.NOK, 'NPR': Currency.NPR, 'NZD': Currency.NZD, 'PAB': Currency.PAB, 'PEN': Currency.PEN, 'PGK': Currency.PGK, 'PHP': Currency.PHP, 'PKR': Currency.PKR, 'PLN': Currency.PLN, 'PYG': Currency.PYG, 'QAR': Currency.QAR, 'RON': Currency.RON, 'RSD': Currency.RSD, 'RUB': Currency.RUB, 'RWF': Currency.RWF, 'SAR': Currency.SAR, 'SBD': Currency.SBD, 'SCR': Currency.SCR, 'SEK': Currency.SEK, 'SGD': Currency.SGD, 'SHP': Currency.SHP, 'SLL': Currency.SLL, 'SOS': Currency.SOS, 'SRD': Currency.SRD, 'STD': Currency.STD, 'SVC': Currency.SVC, 'SZL': Currency.SZL, 'THB': Currency.THB, 'TJS': Currency.TJS, 'TOP': Currency.TOP, 'TRY': Currency.TRY, 'TTD': Currency.TTD, 'TWD': Currency.TWD, 'TZS': Currency.TZS, 'UAH': Currency.UAH, 'UGX': Currency.UGX, 'USD': Currency.USD, 'UYU': Currency.UYU, 'UZS': Currency.UZS, 'VEF': Currency.VEF, 'VND': Currency.VND, 'VUV': Currency.VUV, 'WST': Currency.WST, 'XAF': Currency.XAF, 'XCD': Currency.XCD, 'XOF': Currency.XOF, 'XPF': Currency.XPF, 'YER': Currency.YER, 'ZAR': Currency.ZAR, 'ZMW': Currency.ZMW}

['AED', 'AFN', 'ALL', 'AMD', 'ANG', 'AOA', 'ARS', 'AUD', 'AWG', 'AZN', 'BAM', 'BBD', 'BDT', 'BGN', 'BIF', 'BMD', 'BND', 'BOB', 'BRL', 'BSD', 'BWP', 'BZD', 'CAD', 'CDF', 'CHF', 'CLP', 'CNY', 'COP', 'CRC', 'CVE', 'CZK', 'DJF', 'DKK', 'DOP', 'DZD', 'EEK', 'EGP', 'ETB', 'EUR', 'FJD', 'FKP', 'GBP', 'GEL', 'GIP', 'GMD', 'GNF', 'GTQ', 'GYD', 'HKD', 'HNL', 'HRK', 'HTG', 'HUF', 'IDR', 'ILS', 'INR', 'ISK', 'JMD', 'JPY', 'KES', 'KGS', 'KHR', 'KMF', 'KRW', 'KYD', 'KZT', 'LAK', 'LBP', 'LKR', 'LRD', 'LSL', 'LTL', 'LVL', 'MAD', 'MDL', 'MGA', 'MKD', 'MNT', 'MOP', 'MRO', 'MUR', 'MVR', 'MWK', 'MXN', 'MYR', 'MZN', 'NAD', 'NGN', 'NIO', 'NOK', 'NPR', 'NZD', 'PAB', 'PEN', 'PGK', 'PHP', 'PKR', 'PLN', 'PYG', 'QAR', 'RON', 'RSD', 'RUB', 'RWF', 'SAR', 'SBD', 'SCR', 'SEK', 'SGD', 'SHP', 'SLL', 'SOS', 'SRD', 'STD', 'SVC', 'SZL', 'THB', 'TJS', 'TOP', 'TRY', 'TTD', 'TWD', 'TZS', 'UAH', 'UGX', 'USD', 'UYU', 'UZS', 'VEF', 'VND', 'VUV', 'WST', 'XAF', 'XCD', 'XOF', 'XPF', 'YER', 'ZAR', 'ZMW']

_unhashable_values_ (kittycad.models.currency.Currency attribute)

_value2member_map_ (kittycad.models.currency.Currency attribute)

{'aed': Currency.AED, 'afn': Currency.AFN, 'all': Currency.ALL, 'amd': Currency.AMD, 'ang': Currency.ANG, 'aoa': Currency.AOA, 'ars': Currency.ARS, 'aud': Currency.AUD, 'awg': Currency.AWG, 'azn': Currency.AZN, 'bam': Currency.BAM, 'bbd': Currency.BBD, 'bdt': Currency.BDT, 'bgn': Currency.BGN, 'bif': Currency.BIF, 'bmd': Currency.BMD, 'bnd': Currency.BND, 'bob': Currency.BOB, 'brl': Currency.BRL, 'bsd': Currency.BSD, 'bwp': Currency.BWP, 'bzd': Currency.BZD, 'cad': Currency.CAD, 'cdf': Currency.CDF, 'chf': Currency.CHF, 'clp': Currency.CLP, 'cny': Currency.CNY, 'cop': Currency.COP, 'crc': Currency.CRC, 'cve': Currency.CVE, 'czk': Currency.CZK, 'djf': Currency.DJF, 'dkk': Currency.DKK, 'dop': Currency.DOP, 'dzd': Currency.DZD, 'eek': Currency.EEK, 'egp': Currency.EGP, 'etb': Currency.ETB, 'eur': Currency.EUR, 'fjd': Currency.FJD, 'fkp': Currency.FKP, 'gbp': Currency.GBP, 'gel': Currency.GEL, 'gip': Currency.GIP, 'gmd': Currency.GMD, 'gnf': Currency.GNF, 'gtq': Currency.GTQ, 'gyd': Currency.GYD, 'hkd': Currency.HKD, 'hnl': Currency.HNL, 'hrk': Currency.HRK, 'htg': Currency.HTG, 'huf': Currency.HUF, 'idr': Currency.IDR, 'ils': Currency.ILS, 'inr': Currency.INR, 'isk': Currency.ISK, 'jmd': Currency.JMD, 'jpy': Currency.JPY, 'kes': Currency.KES, 'kgs': Currency.KGS, 'khr': Currency.KHR, 'kmf': Currency.KMF, 'krw': Currency.KRW, 'kyd': Currency.KYD, 'kzt': Currency.KZT, 'lak': Currency.LAK, 'lbp': Currency.LBP, 'lkr': Currency.LKR, 'lrd': Currency.LRD, 'lsl': Currency.LSL, 'ltl': Currency.LTL, 'lvl': Currency.LVL, 'mad': Currency.MAD, 'mdl': Currency.MDL, 'mga': Currency.MGA, 'mkd': Currency.MKD, 'mnt': Currency.MNT, 'mop': Currency.MOP, 'mro': Currency.MRO, 'mur': Currency.MUR, 'mvr': Currency.MVR, 'mwk': Currency.MWK, 'mxn': Currency.MXN, 'myr': Currency.MYR, 'mzn': Currency.MZN, 'nad': Currency.NAD, 'ngn': Currency.NGN, 'nio': Currency.NIO, 'nok': Currency.NOK, 'npr': Currency.NPR, 'nzd': Currency.NZD, 'pab': Currency.PAB, 'pen': Currency.PEN, 'pgk': Currency.PGK, 'php': Currency.PHP, 'pkr': Currency.PKR, 'pln': Currency.PLN, 'pyg': Currency.PYG, 'qar': Currency.QAR, 'ron': Currency.RON, 'rsd': Currency.RSD, 'rub': Currency.RUB, 'rwf': Currency.RWF, 'sar': Currency.SAR, 'sbd': Currency.SBD, 'scr': Currency.SCR, 'sek': Currency.SEK, 'sgd': Currency.SGD, 'shp': Currency.SHP, 'sll': Currency.SLL, 'sos': Currency.SOS, 'srd': Currency.SRD, 'std': Currency.STD, 'svc': Currency.SVC, 'szl': Currency.SZL, 'thb': Currency.THB, 'tjs': Currency.TJS, 'top': Currency.TOP, 'try': Currency.TRY, 'ttd': Currency.TTD, 'twd': Currency.TWD, 'tzs': Currency.TZS, 'uah': Currency.UAH, 'ugx': Currency.UGX, 'usd': Currency.USD, 'uyu': Currency.UYU, 'uzs': Currency.UZS, 'vef': Currency.VEF, 'vnd': Currency.VND, 'vuv': Currency.VUV, 'wst': Currency.WST, 'xaf': Currency.XAF, 'xcd': Currency.XCD, 'xof': Currency.XOF, 'xpf': Currency.XPF, 'yer': Currency.YER, 'zar': Currency.ZAR, 'zmw': Currency.ZMW}

:py:obj:`__init__ <kittycad.models.currency.Currency.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.currency.Currency.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.currency.Currency.casefold>`\ \(\)

:py:obj:`center <kittycad.models.currency.Currency.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.currency.Currency.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.currency.Currency.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.currency.Currency.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.currency.Currency.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.currency.Currency.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`format_map <kittycad.models.currency.Currency.format_map>`\ \(mapping\)

:py:obj:`index <kittycad.models.currency.Currency.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.currency.Currency.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.currency.Currency.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.currency.Currency.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.currency.Currency.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.currency.Currency.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.currency.Currency.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.currency.Currency.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.currency.Currency.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.currency.Currency.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.currency.Currency.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.currency.Currency.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.currency.Currency.isupper>`\ \(\)

:py:obj:`join <kittycad.models.currency.Currency.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.currency.Currency.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lstrip <kittycad.models.currency.Currency.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.currency.Currency.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.currency.Currency.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.currency.Currency.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.currency.Currency.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.currency.Currency.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.currency.Currency.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.currency.Currency.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.currency.Currency.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.currency.Currency.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.currency.Currency.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.currency.Currency.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.currency.Currency.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.currency.Currency.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.currency.Currency.swapcase>`\ \(\)

:py:obj:`translate <kittycad.models.currency.Currency.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.currency.Currency.zfill>`\ \(width\, \/\)

AED

# Afghan Afghani

AFN

# Albanian Lek

ALL

# Armenian Dram

AMD

# Netherlands Antillean Gulden

ANG

# Angolan Kwanza

AOA

# Argentine Peso

ARS

# Australian Dollar

AUD

# Aruban Florin

AWG

# Azerbaijani Manat

AZN

# Bosnia & Herzegovina Convertible Mark

BAM

# Barbadian Dollar

BBD

# Bangladeshi Taka

BDT

# Bulgarian Lev

BGN

# Burundian Franc

BIF

# Bermudian Dollar

BMD

# Brunei Dollar

BND

# Bolivian Boliviano

BOB

# Brazilian Real

BRL

# Bahamian Dollar

BSD

# Botswana Pula

BWP

# Belize Dollar

BZD

# Canadian Dollar

CAD

# Congolese Franc

CDF

# Swiss Franc

CHF

# Chilean Peso

CLP

# Chinese Renminbi Yuan

CNY

# Colombian Peso

COP

# Costa Rican Colón

CRC

# Cape Verdean Escudo

CVE

# Czech Koruna

CZK

# Djiboutian Franc

DJF

# Danish Krone

DKK

# Dominican Peso

DOP

# Algerian Dinar

DZD

# Estonian Kroon

EEK

# Egyptian Pound

EGP

# Ethiopian Birr

ETB

# Euro

EUR

# Fijian Dollar

FJD

# Falkland Islands Pound

FKP

# British Pound

GBP

# Georgian Lari

GEL

# Gibraltar Pound

GIP

# Gambian Dalasi

GMD

# Guinean Franc

GNF

# Guatemalan Quetzal

GTQ

# Guyanese Dollar

GYD

# Hong Kong Dollar

HKD

# Honduran Lempira

HNL

# Croatian Kuna

HRK

# Haitian Gourde

HTG

# Hungarian Forint

HUF

# Indonesian Rupiah

IDR

# Israeli New Sheqel

ILS

# Indian Rupee

INR

# Icelandic Króna

ISK

# Jamaican Dollar

JMD

# Japanese Yen

JPY

# Kenyan Shilling

KES

# Kyrgyzstani Som

KGS

# Cambodian Riel

KHR

# Comorian Franc

KMF

# South Korean Won

KRW

# Cayman Islands Dollar

KYD

# Kazakhstani Tenge

KZT

# Lao Kip

LAK

# Lebanese Pound

LBP

# Sri Lankan Rupee

LKR

# Liberian Dollar

LRD

# Lesotho Loti

LSL

# Lithuanian Litas

LTL

# Latvian Lats

LVL

# Moroccan Dirham

MAD

# Moldovan Leu

MDL

# Malagasy Ariary

MGA

# Macedonian Denar

MKD

# Mongolian Tögrög

MNT

# Macanese Pataca

MOP

# Mauritanian Ouguiya

MRO

# Mauritian Rupee

MUR

# Maldivian Rufiyaa

MVR

# Malawian Kwacha

MWK

# Mexican Peso

MXN

# Malaysian Ringgit

MYR

# Mozambican Metical

MZN

# Namibian Dollar

NAD

# Nigerian Naira

NGN

# Nicaraguan Córdoba

NIO

# Norwegian Krone

NOK

# Nepalese Rupee

NPR

# New Zealand Dollar

NZD

# Panamanian Balboa

PAB

# Peruvian Nuevo Sol

PEN

# Papua New Guinean Kina

PGK

# Philippine Peso

PHP

# Pakistani Rupee

PKR

# Polish Złoty

PLN

# Paraguayan Guaraní

PYG

# Qatari Riyal

QAR

# Romanian Leu

RON

# Serbian Dinar

RSD

# Russian Ruble

RUB

# Rwandan Franc

RWF

# Saudi Riyal

SAR

# Solomon Islands Dollar

SBD

# Seychellois Rupee

SCR

# Swedish Krona

SEK

# Singapore Dollar

SGD

# Saint Helenian Pound

SHP

# Sierra Leonean Leone

SLL

# Somali Shilling

SOS

# Surinamese Dollar

SRD

# São Tomé and Príncipe Dobra

STD

# Salvadoran Colón

SVC

# Swazi Lilangeni

SZL

# Thai Baht

THB

# Tajikistani Somoni

TJS

# Tongan Paʻanga

TOP

# Turkish Lira

TRY

# Trinidad and Tobago Dollar

TTD

# New Taiwan Dollar

TWD

# Tanzanian Shilling

TZS

# Ukrainian Hryvnia

UAH

# Ugandan Shilling

UGX

# United States Dollar

USD

# Uruguayan Peso

UYU

# Uzbekistani Som

UZS

# Venezuelan Bolívar

VEF

# Vietnamese Đồng

VND

# Vanuatu Vatu

VUV

# Samoan Tala

WST

# Central African Cfa Franc

XAF

# East Caribbean Dollar

XCD

# West African Cfa Franc

XOF

# Cfp Franc

XPF

# Yemeni Rial

YER

# South African Rand

ZAR

# Zambian Kwacha

ZMW

Customer([address, balance, created_at, ...])

The resource representing a payment "Customer".

:py:obj:`Customer <kittycad.models.customer.Customer>`\ \(\[address\, balance\, created\_at\, ...\]\)

Customer(address=<kittycad.types.Unset object>, balance=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, delinquent=False, email=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

(address=<kittycad.types.Unset object>, balance=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, delinquent=False, email=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'address': typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], 'balance': typing.Union[kittycad.types.Unset, float], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'delinquent': typing.Union[kittycad.types.Unset, bool], 'email': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address'), Attribute(name='balance', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='balance'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='delinquent', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='delinquent'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.customer', '__annotations__': {'address': typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], 'balance': typing.Union[kittycad.types.Unset, float], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'delinquent': typing.Union[kittycad.types.Unset, bool], 'email': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The resource representing a payment "Customer".', 'to_dict': <function Customer.to_dict>, 'from_dict': <classmethod(<function Customer.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Customer.__getitem__>, '__setitem__': <function Customer.__setitem__>, '__delitem__': <function Customer.__delitem__>, '__contains__': <function Customer.__contains__>, '__dict__': <attribute '__dict__' of 'Customer' objects>, '__weakref__': <attribute '__weakref__' of 'Customer' objects>, '__attrs_attrs__': (Attribute(name='address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.new_address.NewAddress], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address'), Attribute(name='balance', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='balance'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='delinquent', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='delinquent'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Customer.__repr__>, '__eq__': <function Customer.__eq__>, '__ne__': <function Customer.__ne__>, '__lt__': <function Customer.__lt__>, '__le__': <function Customer.__le__>, '__gt__': <function Customer.__gt__>, '__ge__': <function Customer.__ge__>, '__hash__': None, '__init__': <function Customer.__init__>, '__match_args__': ('address', 'balance', 'created_at', 'currency', 'delinquent', 'email', 'id', 'metadata', 'name', 'phone')})

Customer.__init__(address=<kittycad.types.Unset object>, balance=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, delinquent=False, email=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

('address', 'balance', 'created_at', 'currency', 'delinquent', 'email', 'id', 'metadata', 'name', 'phone')

additional_properties (kittycad.models.customer.Customer attribute)

__init__([address, balance, created_at, ...])

Method generated by attrs for class Customer.

rtype

TypeVar(US, bound= Customer)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.customer.Customer.__init__>`\ \(\[address\, balance\, created\_at\, ...\]\)

:py:obj:`from_dict <kittycad.models.customer.Customer.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.customer.Customer.to_dict>`\ \(\)

address

balance

currency

delinquent

email

id

metadata

name

phone

CustomerBalance([created_at, id, ...])

A balance for a user.

:py:obj:`CustomerBalance <kittycad.models.customer_balance.CustomerBalance>`\ \(\[created\_at\, id\, ...\]\)

CustomerBalance(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, monthly_credits_remaining=<kittycad.types.Unset object>, pre_pay_cash_remaining=<kittycad.types.Unset object>, pre_pay_credits_remaining=<kittycad.types.Unset object>, total_due=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, monthly_credits_remaining=<kittycad.types.Unset object>, pre_pay_cash_remaining=<kittycad.types.Unset object>, pre_pay_credits_remaining=<kittycad.types.Unset object>, total_due=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

This holds information about the financial balance for the user.

__annotations__ (kittycad.models.customer_balance.CustomerBalance attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'monthly_credits_remaining': typing.Union[kittycad.types.Unset, float], 'pre_pay_cash_remaining': typing.Union[kittycad.types.Unset, float], 'pre_pay_credits_remaining': typing.Union[kittycad.types.Unset, float], 'total_due': typing.Union[kittycad.types.Unset, float], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.customer_balance.CustomerBalance attribute)

(Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='monthly_credits_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='monthly_credits_remaining'), Attribute(name='pre_pay_cash_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pre_pay_cash_remaining'), Attribute(name='pre_pay_credits_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pre_pay_credits_remaining'), Attribute(name='total_due', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total_due'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.customer_balance.CustomerBalance method)

__delitem__() (kittycad.models.customer_balance.CustomerBalance method)

__dict__ (kittycad.models.customer_balance.CustomerBalance attribute)

mappingproxy({'__module__': 'kittycad.models.customer_balance', '__annotations__': {'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'monthly_credits_remaining': typing.Union[kittycad.types.Unset, float], 'pre_pay_cash_remaining': typing.Union[kittycad.types.Unset, float], 'pre_pay_credits_remaining': typing.Union[kittycad.types.Unset, float], 'total_due': typing.Union[kittycad.types.Unset, float], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A balance for a user.\n\n    This holds information about the financial balance for the user.', 'to_dict': <function CustomerBalance.to_dict>, 'from_dict': <classmethod(<function CustomerBalance.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function CustomerBalance.__getitem__>, '__setitem__': <function CustomerBalance.__setitem__>, '__delitem__': <function CustomerBalance.__delitem__>, '__contains__': <function CustomerBalance.__contains__>, '__dict__': <attribute '__dict__' of 'CustomerBalance' objects>, '__weakref__': <attribute '__weakref__' of 'CustomerBalance' objects>, '__attrs_attrs__': (Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='monthly_credits_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='monthly_credits_remaining'), Attribute(name='pre_pay_cash_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pre_pay_cash_remaining'), Attribute(name='pre_pay_credits_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pre_pay_credits_remaining'), Attribute(name='total_due', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total_due'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function CustomerBalance.__repr__>, '__eq__': <function CustomerBalance.__eq__>, '__ne__': <function CustomerBalance.__ne__>, '__lt__': <function CustomerBalance.__lt__>, '__le__': <function CustomerBalance.__le__>, '__gt__': <function CustomerBalance.__gt__>, '__ge__': <function CustomerBalance.__ge__>, '__hash__': None, '__init__': <function CustomerBalance.__init__>, '__match_args__': ('created_at', 'id', 'monthly_credits_remaining', 'pre_pay_cash_remaining', 'pre_pay_credits_remaining', 'total_due', 'updated_at', 'user_id')})

__eq__() (kittycad.models.customer_balance.CustomerBalance method)

__ge__() (kittycad.models.customer_balance.CustomerBalance method)

__getitem__() (kittycad.models.customer_balance.CustomerBalance method)

__gt__() (kittycad.models.customer_balance.CustomerBalance method)

__hash__ (kittycad.models.customer_balance.CustomerBalance attribute)

__init__() (kittycad.models.customer_balance.CustomerBalance method)

CustomerBalance.__init__(created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, monthly_credits_remaining=<kittycad.types.Unset object>, pre_pay_cash_remaining=<kittycad.types.Unset object>, pre_pay_credits_remaining=<kittycad.types.Unset object>, total_due=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.customer_balance.CustomerBalance method)

__lt__() (kittycad.models.customer_balance.CustomerBalance method)

__match_args__ (kittycad.models.customer_balance.CustomerBalance attribute)

('created_at', 'id', 'monthly_credits_remaining', 'pre_pay_cash_remaining', 'pre_pay_credits_remaining', 'total_due', 'updated_at', 'user_id')

__module__ (kittycad.models.customer_balance.CustomerBalance attribute)

__ne__() (kittycad.models.customer_balance.CustomerBalance method)

__repr__() (kittycad.models.customer_balance.CustomerBalance method)

__setitem__() (kittycad.models.customer_balance.CustomerBalance method)

additional_keys (kittycad.models.customer_balance.CustomerBalance property)

created_at (kittycad.models.customer_balance.CustomerBalance attribute)

from_dict() (kittycad.models.customer_balance.CustomerBalance class method)

to_dict() (kittycad.models.customer_balance.CustomerBalance method)

total_due (kittycad.models.customer_balance.CustomerBalance attribute)

updated_at (kittycad.models.customer_balance.CustomerBalance attribute)

user_id (kittycad.models.customer_balance.CustomerBalance attribute)

__init__([created_at, id, ...])

Method generated by attrs for class CustomerBalance.

rtype

TypeVar(KQ, bound= CustomerBalance)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.customer_balance.CustomerBalance.__init__>`\ \(\[created\_at\, id\, ...\]\)

id

monthly_credits_remaining

pre_pay_cash_remaining

pre_pay_credits_remaining

total_due

user_id

DeviceAccessTokenRequestForm([client_id, ...])

The form for a device access token request.

DeviceAccessTokenRequestForm (class in kittycad.models.device_access_token_request_form)

DeviceAccessTokenRequestForm(client_id=<kittycad.types.Unset object>, device_code=<kittycad.types.Unset object>, grant_type=<kittycad.types.Unset object>)

(client_id=<kittycad.types.Unset object>, device_code=<kittycad.types.Unset object>, grant_type=<kittycad.types.Unset object>)

Method generated by attrs for class DeviceAccessTokenRequestForm.

{'additional_properties': typing.Dict[str, typing.Any], 'client_id': typing.Union[kittycad.types.Unset, str], 'device_code': typing.Union[kittycad.types.Unset, str], 'grant_type': typing.Union[kittycad.types.Unset, kittycad.models.o_auth2_grant_type.OAuth2GrantType]}

(Attribute(name='client_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_id'), Attribute(name='device_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='device_code'), Attribute(name='grant_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.o_auth2_grant_type.OAuth2GrantType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='grant_type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.device_access_token_request_form', '__annotations__': {'client_id': typing.Union[kittycad.types.Unset, str], 'device_code': typing.Union[kittycad.types.Unset, str], 'grant_type': typing.Union[kittycad.types.Unset, kittycad.models.o_auth2_grant_type.OAuth2GrantType], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The form for a device access token request.', 'to_dict': <function DeviceAccessTokenRequestForm.to_dict>, 'from_dict': <classmethod(<function DeviceAccessTokenRequestForm.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function DeviceAccessTokenRequestForm.__getitem__>, '__setitem__': <function DeviceAccessTokenRequestForm.__setitem__>, '__delitem__': <function DeviceAccessTokenRequestForm.__delitem__>, '__contains__': <function DeviceAccessTokenRequestForm.__contains__>, '__dict__': <attribute '__dict__' of 'DeviceAccessTokenRequestForm' objects>, '__weakref__': <attribute '__weakref__' of 'DeviceAccessTokenRequestForm' objects>, '__attrs_attrs__': (Attribute(name='client_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_id'), Attribute(name='device_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='device_code'), Attribute(name='grant_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.o_auth2_grant_type.OAuth2GrantType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='grant_type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function DeviceAccessTokenRequestForm.__repr__>, '__eq__': <function DeviceAccessTokenRequestForm.__eq__>, '__ne__': <function DeviceAccessTokenRequestForm.__ne__>, '__lt__': <function DeviceAccessTokenRequestForm.__lt__>, '__le__': <function DeviceAccessTokenRequestForm.__le__>, '__gt__': <function DeviceAccessTokenRequestForm.__gt__>, '__ge__': <function DeviceAccessTokenRequestForm.__ge__>, '__hash__': None, '__init__': <function DeviceAccessTokenRequestForm.__init__>, '__match_args__': ('client_id', 'device_code', 'grant_type')})

DeviceAccessTokenRequestForm.__init__(client_id=<kittycad.types.Unset object>, device_code=<kittycad.types.Unset object>, grant_type=<kittycad.types.Unset object>)

from_dict() (kittycad.models.device_access_token_request_form.DeviceAccessTokenRequestForm class method)

__init__([client_id, device_code, grant_type])

rtype

TypeVar(FH, bound= DeviceAccessTokenRequestForm)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.device_access_token_request_form.DeviceAccessTokenRequestForm.__init__>`\ \(\[client\_id\, device\_code\, grant\_type\]\)

:py:class:`~typing.TypeVar`\(``FH``, bound= DeviceAccessTokenRequestForm)

client_id

device_code

grant_type

DeviceAuthRequestForm([client_id])

The request parameters for the OAuth 2.0 Device Authorization Grant flow.

DeviceAuthRequestForm (class in kittycad.models.device_auth_request_form)

{'additional_properties': typing.Dict[str, typing.Any], 'client_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='client_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.device_auth_request_form', '__annotations__': {'client_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The request parameters for the OAuth 2.0 Device Authorization Grant flow.', 'to_dict': <function DeviceAuthRequestForm.to_dict>, 'from_dict': <classmethod(<function DeviceAuthRequestForm.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function DeviceAuthRequestForm.__getitem__>, '__setitem__': <function DeviceAuthRequestForm.__setitem__>, '__delitem__': <function DeviceAuthRequestForm.__delitem__>, '__contains__': <function DeviceAuthRequestForm.__contains__>, '__dict__': <attribute '__dict__' of 'DeviceAuthRequestForm' objects>, '__weakref__': <attribute '__weakref__' of 'DeviceAuthRequestForm' objects>, '__attrs_attrs__': (Attribute(name='client_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function DeviceAuthRequestForm.__repr__>, '__eq__': <function DeviceAuthRequestForm.__eq__>, '__ne__': <function DeviceAuthRequestForm.__ne__>, '__lt__': <function DeviceAuthRequestForm.__lt__>, '__le__': <function DeviceAuthRequestForm.__le__>, '__gt__': <function DeviceAuthRequestForm.__gt__>, '__ge__': <function DeviceAuthRequestForm.__ge__>, '__hash__': None, '__init__': <function DeviceAuthRequestForm.__init__>, '__match_args__': ('client_id',)})

__eq__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

__ge__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

__gt__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

__le__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

__lt__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

__ne__() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm method)

from_dict() (kittycad.models.device_auth_request_form.DeviceAuthRequestForm class method)

__init__([client_id])

Method generated by attrs for class DeviceAuthRequestForm.

rtype

TypeVar(NH, bound= DeviceAuthRequestForm)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``NH``, bound= DeviceAuthRequestForm)

DeviceAuthVerifyParams([user_code])

The request parameters to verify the user_code for the OAuth 2.0 Device Authorization Grant.

The request parameters to verify the `user_code` for the OAuth 2.0 Device Authorization Grant.

DeviceAuthVerifyParams (class in kittycad.models.device_auth_verify_params)

{'additional_properties': typing.Dict[str, typing.Any], 'user_code': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='user_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_code'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.device_auth_verify_params', '__annotations__': {'user_code': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The request parameters to verify the `user_code` for the OAuth 2.0 Device Authorization Grant.', 'to_dict': <function DeviceAuthVerifyParams.to_dict>, 'from_dict': <classmethod(<function DeviceAuthVerifyParams.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function DeviceAuthVerifyParams.__getitem__>, '__setitem__': <function DeviceAuthVerifyParams.__setitem__>, '__delitem__': <function DeviceAuthVerifyParams.__delitem__>, '__contains__': <function DeviceAuthVerifyParams.__contains__>, '__dict__': <attribute '__dict__' of 'DeviceAuthVerifyParams' objects>, '__weakref__': <attribute '__weakref__' of 'DeviceAuthVerifyParams' objects>, '__attrs_attrs__': (Attribute(name='user_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_code'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function DeviceAuthVerifyParams.__repr__>, '__eq__': <function DeviceAuthVerifyParams.__eq__>, '__ne__': <function DeviceAuthVerifyParams.__ne__>, '__lt__': <function DeviceAuthVerifyParams.__lt__>, '__le__': <function DeviceAuthVerifyParams.__le__>, '__gt__': <function DeviceAuthVerifyParams.__gt__>, '__ge__': <function DeviceAuthVerifyParams.__ge__>, '__hash__': None, '__init__': <function DeviceAuthVerifyParams.__init__>, '__match_args__': ('user_code',)})

from_dict() (kittycad.models.device_auth_verify_params.DeviceAuthVerifyParams class method)

__init__([user_code])

Method generated by attrs for class DeviceAuthVerifyParams.

rtype

TypeVar(BB, bound= DeviceAuthVerifyParams)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``BB``, bound= DeviceAuthVerifyParams)

Direction(value[, names, module, qualname, ...])

Specifies the sign of a co-ordinate axis.

:py:obj:`Direction <kittycad.models.direction.Direction>`\ \(value\[\, names\, module\, qualname\, ...\]\)

Direction(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.direction', '__doc__': 'Specifies the sign of a co-ordinate axis.', '__str__': <function Direction.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['POSITIVE', 'NEGATIVE'], '_member_map_': {'POSITIVE': <Direction.POSITIVE: 'positive'>, 'NEGATIVE': <Direction.NEGATIVE: 'negative'>}, '_value2member_map_': {'positive': <Direction.POSITIVE: 'positive'>, 'negative': <Direction.NEGATIVE: 'negative'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Direction' objects>, '__weakref__': <attribute '__weakref__' of 'Direction' objects>, 'POSITIVE': <Direction.POSITIVE: 'positive'>, 'NEGATIVE': <Direction.NEGATIVE: 'negative'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

_generate_next_value_() (kittycad.models.direction.Direction method)

{'NEGATIVE': Direction.NEGATIVE, 'POSITIVE': Direction.POSITIVE}

_unhashable_values_ (kittycad.models.direction.Direction attribute)

_value2member_map_ (kittycad.models.direction.Direction attribute)

{'negative': Direction.NEGATIVE, 'positive': Direction.POSITIVE}

:py:obj:`__init__ <kittycad.models.direction.Direction.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.direction.Direction.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.direction.Direction.casefold>`\ \(\)

:py:obj:`center <kittycad.models.direction.Direction.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.direction.Direction.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.direction.Direction.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.direction.Direction.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.direction.Direction.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.direction.Direction.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.direction.Direction.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.direction.Direction.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.direction.Direction.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.direction.Direction.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.direction.Direction.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.direction.Direction.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.direction.Direction.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.direction.Direction.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.direction.Direction.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.direction.Direction.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.direction.Direction.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.direction.Direction.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.direction.Direction.isupper>`\ \(\)

:py:obj:`join <kittycad.models.direction.Direction.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.direction.Direction.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.direction.Direction.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.direction.Direction.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.direction.Direction.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.direction.Direction.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.direction.Direction.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.direction.Direction.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.direction.Direction.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.direction.Direction.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.direction.Direction.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.direction.Direction.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.direction.Direction.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.direction.Direction.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.direction.Direction.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.direction.Direction.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.direction.Direction.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.direction.Direction.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.direction.Direction.title>`\ \(\)

:py:obj:`translate <kittycad.models.direction.Direction.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.direction.Direction.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.direction.Direction.zfill>`\ \(width\, \/\)

:py:obj:`Discount <kittycad.models.discount.Discount>`\ \(\[coupon\]\)

{'additional_properties': typing.Dict[str, typing.Any], 'coupon': typing.Union[kittycad.types.Unset, kittycad.models.coupon.Coupon]}

(Attribute(name='coupon', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.coupon.Coupon], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coupon'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.discount', '__annotations__': {'coupon': typing.Union[kittycad.types.Unset, kittycad.models.coupon.Coupon], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The resource representing a Discount.', 'to_dict': <function Discount.to_dict>, 'from_dict': <classmethod(<function Discount.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Discount.__getitem__>, '__setitem__': <function Discount.__setitem__>, '__delitem__': <function Discount.__delitem__>, '__contains__': <function Discount.__contains__>, '__dict__': <attribute '__dict__' of 'Discount' objects>, '__weakref__': <attribute '__weakref__' of 'Discount' objects>, '__attrs_attrs__': (Attribute(name='coupon', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.coupon.Coupon], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coupon'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Discount.__repr__>, '__eq__': <function Discount.__eq__>, '__ne__': <function Discount.__ne__>, '__lt__': <function Discount.__lt__>, '__le__': <function Discount.__le__>, '__gt__': <function Discount.__gt__>, '__ge__': <function Discount.__ge__>, '__hash__': None, '__init__': <function Discount.__init__>, '__match_args__': ('coupon',)})

additional_properties (kittycad.models.discount.Discount attribute)

__init__([coupon])

Method generated by attrs for class Discount.

rtype

TypeVar(PJ, bound= Discount)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.discount.Discount.__init__>`\ \(\[coupon\]\)

:py:obj:`from_dict <kittycad.models.discount.Discount.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.discount.Discount.to_dict>`\ \(\)

:py:obj:`DockerSystemInfo <kittycad.models.docker_system_info.DockerSystemInfo>`\ \(\[architecture\, ...\]\)

DockerSystemInfo(architecture=<kittycad.types.Unset object>, bridge_nf_ip6tables=False, bridge_nf_iptables=False, cgroup_driver=<kittycad.types.Unset object>, cgroup_version=<kittycad.types.Unset object>, cluster_advertise=<kittycad.types.Unset object>, cluster_store=<kittycad.types.Unset object>, containerd_commit=<kittycad.types.Unset object>, containers=<kittycad.types.Unset object>, containers_paused=<kittycad.types.Unset object>, containers_running=<kittycad.types.Unset object>, containers_stopped=<kittycad.types.Unset object>, cpu_cfs_period=False, cpu_cfs_quota=False, cpu_set=False, cpu_shares=False, debug=False, default_address_pools=<kittycad.types.Unset object>, default_runtime=<kittycad.types.Unset object>, docker_root_dir=<kittycad.types.Unset object>, driver=<kittycad.types.Unset object>, driver_status=<kittycad.types.Unset object>, experimental_build=False, http_proxy=<kittycad.types.Unset object>, https_proxy=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, images=<kittycad.types.Unset object>, index_server_address=<kittycad.types.Unset object>, init_binary=<kittycad.types.Unset object>, init_commit=<kittycad.types.Unset object>, ipv4_forwarding=False, isolation=<kittycad.types.Unset object>, kernel_memory=False, kernel_memory_tcp=False, kernel_version=<kittycad.types.Unset object>, labels=<kittycad.types.Unset object>, live_restore_enabled=False, logging_driver=<kittycad.types.Unset object>, mem_total=<kittycad.types.Unset object>, memory_limit=False, n_events_listener=<kittycad.types.Unset object>, n_fd=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, ncpu=<kittycad.types.Unset object>, no_proxy=<kittycad.types.Unset object>, oom_kill_disable=False, operating_system=<kittycad.types.Unset object>, os_type=<kittycad.types.Unset object>, os_version=<kittycad.types.Unset object>, pids_limit=False, plugins=<kittycad.types.Unset object>, product_license=<kittycad.types.Unset object>, registry_config=<kittycad.types.Unset object>, runc_commit=<kittycad.types.Unset object>, runtimes=<kittycad.types.Unset object>, security_options=<kittycad.types.Unset object>, server_version=<kittycad.types.Unset object>, swap_limit=False, system_time=<kittycad.types.Unset object>, warnings=<kittycad.types.Unset object>)

(architecture=<kittycad.types.Unset object>, bridge_nf_ip6tables=False, bridge_nf_iptables=False, cgroup_driver=<kittycad.types.Unset object>, cgroup_version=<kittycad.types.Unset object>, cluster_advertise=<kittycad.types.Unset object>, cluster_store=<kittycad.types.Unset object>, containerd_commit=<kittycad.types.Unset object>, containers=<kittycad.types.Unset object>, containers_paused=<kittycad.types.Unset object>, containers_running=<kittycad.types.Unset object>, containers_stopped=<kittycad.types.Unset object>, cpu_cfs_period=False, cpu_cfs_quota=False, cpu_set=False, cpu_shares=False, debug=False, default_address_pools=<kittycad.types.Unset object>, default_runtime=<kittycad.types.Unset object>, docker_root_dir=<kittycad.types.Unset object>, driver=<kittycad.types.Unset object>, driver_status=<kittycad.types.Unset object>, experimental_build=False, http_proxy=<kittycad.types.Unset object>, https_proxy=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, images=<kittycad.types.Unset object>, index_server_address=<kittycad.types.Unset object>, init_binary=<kittycad.types.Unset object>, init_commit=<kittycad.types.Unset object>, ipv4_forwarding=False, isolation=<kittycad.types.Unset object>, kernel_memory=False, kernel_memory_tcp=False, kernel_version=<kittycad.types.Unset object>, labels=<kittycad.types.Unset object>, live_restore_enabled=False, logging_driver=<kittycad.types.Unset object>, mem_total=<kittycad.types.Unset object>, memory_limit=False, n_events_listener=<kittycad.types.Unset object>, n_fd=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, ncpu=<kittycad.types.Unset object>, no_proxy=<kittycad.types.Unset object>, oom_kill_disable=False, operating_system=<kittycad.types.Unset object>, os_type=<kittycad.types.Unset object>, os_version=<kittycad.types.Unset object>, pids_limit=False, plugins=<kittycad.types.Unset object>, product_license=<kittycad.types.Unset object>, registry_config=<kittycad.types.Unset object>, runc_commit=<kittycad.types.Unset object>, runtimes=<kittycad.types.Unset object>, security_options=<kittycad.types.Unset object>, server_version=<kittycad.types.Unset object>, swap_limit=False, system_time=<kittycad.types.Unset object>, warnings=<kittycad.types.Unset object>)

DockerSystemInfo.SystemInfoDefaultAddressPools (class in kittycad.models.docker_system_info)

DockerSystemInfo.SystemInfoDefaultAddressPools(base=<kittycad.types.Unset object>, size=<kittycad.types.Unset object>)

(base=<kittycad.types.Unset object>, size=<kittycad.types.Unset object>)

Method generated by attrs for class SystemInfoDefaultAddressPools.

{'additional_properties': typing.Dict[str, typing.Any], 'base': typing.Union[kittycad.types.Unset, str], 'size': typing.Union[kittycad.types.Unset, int]}

(Attribute(name='base', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='base'), Attribute(name='size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='size'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.system_info_default_address_pools', '__annotations__': {'base': typing.Union[kittycad.types.Unset, str], 'size': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, 'to_dict': <function SystemInfoDefaultAddressPools.to_dict>, 'from_dict': <classmethod(<function SystemInfoDefaultAddressPools.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function SystemInfoDefaultAddressPools.__getitem__>, '__setitem__': <function SystemInfoDefaultAddressPools.__setitem__>, '__delitem__': <function SystemInfoDefaultAddressPools.__delitem__>, '__contains__': <function SystemInfoDefaultAddressPools.__contains__>, '__dict__': <attribute '__dict__' of 'SystemInfoDefaultAddressPools' objects>, '__weakref__': <attribute '__weakref__' of 'SystemInfoDefaultAddressPools' objects>, '__doc__': None, '__attrs_attrs__': (Attribute(name='base', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='base'), Attribute(name='size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='size'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function SystemInfoDefaultAddressPools.__repr__>, '__eq__': <function SystemInfoDefaultAddressPools.__eq__>, '__ne__': <function SystemInfoDefaultAddressPools.__ne__>, '__lt__': <function SystemInfoDefaultAddressPools.__lt__>, '__le__': <function SystemInfoDefaultAddressPools.__le__>, '__gt__': <function SystemInfoDefaultAddressPools.__gt__>, '__ge__': <function SystemInfoDefaultAddressPools.__ge__>, '__hash__': None, '__init__': <function SystemInfoDefaultAddressPools.__init__>, '__match_args__': ('base', 'size')})

from_dict() (kittycad.models.docker_system_info.DockerSystemInfo.SystemInfoDefaultAddressPools class method)

__annotations__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'architecture': typing.Union[kittycad.types.Unset, str], 'bridge_nf_ip6tables': typing.Union[kittycad.types.Unset, bool], 'bridge_nf_iptables': typing.Union[kittycad.types.Unset, bool], 'cgroup_driver': typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum], 'cgroup_version': typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum], 'cluster_advertise': typing.Union[kittycad.types.Unset, str], 'cluster_store': typing.Union[kittycad.types.Unset, str], 'containerd_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'containers': typing.Union[kittycad.types.Unset, int], 'containers_paused': typing.Union[kittycad.types.Unset, int], 'containers_running': typing.Union[kittycad.types.Unset, int], 'containers_stopped': typing.Union[kittycad.types.Unset, int], 'cpu_cfs_period': typing.Union[kittycad.types.Unset, bool], 'cpu_cfs_quota': typing.Union[kittycad.types.Unset, bool], 'cpu_set': typing.Union[kittycad.types.Unset, bool], 'cpu_shares': typing.Union[kittycad.types.Unset, bool], 'debug': typing.Union[kittycad.types.Unset, bool], 'default_address_pools': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools]], 'default_runtime': typing.Union[kittycad.types.Unset, str], 'docker_root_dir': typing.Union[kittycad.types.Unset, str], 'driver': typing.Union[kittycad.types.Unset, str], 'driver_status': typing.Union[kittycad.types.Unset, typing.List[typing.List[str]]], 'experimental_build': typing.Union[kittycad.types.Unset, bool], 'http_proxy': typing.Union[kittycad.types.Unset, str], 'https_proxy': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'images': typing.Union[kittycad.types.Unset, int], 'index_server_address': typing.Union[kittycad.types.Unset, str], 'init_binary': typing.Union[kittycad.types.Unset, str], 'init_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'ipv4_forwarding': typing.Union[kittycad.types.Unset, bool], 'isolation': typing.Union[kittycad.types.Unset, kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum], 'kernel_memory': typing.Union[kittycad.types.Unset, bool], 'kernel_memory_tcp': typing.Union[kittycad.types.Unset, bool], 'kernel_version': typing.Union[kittycad.types.Unset, str], 'labels': typing.Union[kittycad.types.Unset, typing.List[str]], 'live_restore_enabled': typing.Union[kittycad.types.Unset, bool], 'logging_driver': typing.Union[kittycad.types.Unset, str], 'mem_total': typing.Union[kittycad.types.Unset, int], 'memory_limit': typing.Union[kittycad.types.Unset, bool], 'n_events_listener': typing.Union[kittycad.types.Unset, int], 'n_fd': typing.Union[kittycad.types.Unset, int], 'name': typing.Union[kittycad.types.Unset, str], 'ncpu': typing.Union[kittycad.types.Unset, int], 'no_proxy': typing.Union[kittycad.types.Unset, str], 'oom_kill_disable': typing.Union[kittycad.types.Unset, bool], 'operating_system': typing.Union[kittycad.types.Unset, str], 'os_type': typing.Union[kittycad.types.Unset, str], 'os_version': typing.Union[kittycad.types.Unset, str], 'pids_limit': typing.Union[kittycad.types.Unset, bool], 'plugins': typing.Union[kittycad.types.Unset, kittycad.models.plugins_info.PluginsInfo], 'product_license': typing.Union[kittycad.types.Unset, str], 'registry_config': typing.Union[kittycad.types.Unset, kittycad.models.registry_service_config.RegistryServiceConfig], 'runc_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'runtimes': typing.Union[kittycad.types.Unset, typing.Any], 'security_options': typing.Union[kittycad.types.Unset, typing.List[str]], 'server_version': typing.Union[kittycad.types.Unset, str], 'swap_limit': typing.Union[kittycad.types.Unset, bool], 'system_time': typing.Union[kittycad.types.Unset, str], 'warnings': typing.Union[kittycad.types.Unset, typing.List[str]]}

__attrs_attrs__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

(Attribute(name='architecture', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='architecture'), Attribute(name='bridge_nf_ip6tables', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='bridge_nf_ip6tables'), Attribute(name='bridge_nf_iptables', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='bridge_nf_iptables'), Attribute(name='cgroup_driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cgroup_driver'), Attribute(name='cgroup_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cgroup_version'), Attribute(name='cluster_advertise', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_advertise'), Attribute(name='cluster_store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_store'), Attribute(name='containerd_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containerd_commit'), Attribute(name='containers', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers'), Attribute(name='containers_paused', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_paused'), Attribute(name='containers_running', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_running'), Attribute(name='containers_stopped', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_stopped'), Attribute(name='cpu_cfs_period', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_cfs_period'), Attribute(name='cpu_cfs_quota', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_cfs_quota'), Attribute(name='cpu_set', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_set'), Attribute(name='cpu_shares', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_shares'), Attribute(name='debug', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='debug'), Attribute(name='default_address_pools', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_address_pools'), Attribute(name='default_runtime', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_runtime'), Attribute(name='docker_root_dir', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='docker_root_dir'), Attribute(name='driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='driver'), Attribute(name='driver_status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[typing.List[str]]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='driver_status'), Attribute(name='experimental_build', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='experimental_build'), Attribute(name='http_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_proxy'), Attribute(name='https_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='https_proxy'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='images', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='images'), Attribute(name='index_server_address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='index_server_address'), Attribute(name='init_binary', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='init_binary'), Attribute(name='init_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='init_commit'), Attribute(name='ipv4_forwarding', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ipv4_forwarding'), Attribute(name='isolation', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='isolation'), Attribute(name='kernel_memory', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_memory'), Attribute(name='kernel_memory_tcp', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_memory_tcp'), Attribute(name='kernel_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_version'), Attribute(name='labels', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='labels'), Attribute(name='live_restore_enabled', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='live_restore_enabled'), Attribute(name='logging_driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='logging_driver'), Attribute(name='mem_total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mem_total'), Attribute(name='memory_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='memory_limit'), Attribute(name='n_events_listener', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='n_events_listener'), Attribute(name='n_fd', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='n_fd'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='ncpu', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ncpu'), Attribute(name='no_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='no_proxy'), Attribute(name='oom_kill_disable', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='oom_kill_disable'), Attribute(name='operating_system', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='operating_system'), Attribute(name='os_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='os_type'), Attribute(name='os_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='os_version'), Attribute(name='pids_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pids_limit'), Attribute(name='plugins', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.plugins_info.PluginsInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='plugins'), Attribute(name='product_license', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='product_license'), Attribute(name='registry_config', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.registry_service_config.RegistryServiceConfig], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='registry_config'), Attribute(name='runc_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runc_commit'), Attribute(name='runtimes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runtimes'), Attribute(name='security_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='security_options'), Attribute(name='server_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_version'), Attribute(name='swap_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='swap_limit'), Attribute(name='system_time', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='system_time'), Attribute(name='warnings', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='warnings'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__delitem__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__dict__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

mappingproxy({'__module__': 'kittycad.models.docker_system_info', '__annotations__': {'architecture': typing.Union[kittycad.types.Unset, str], 'bridge_nf_ip6tables': typing.Union[kittycad.types.Unset, bool], 'bridge_nf_iptables': typing.Union[kittycad.types.Unset, bool], 'cgroup_driver': typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum], 'cgroup_version': typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum], 'cluster_advertise': typing.Union[kittycad.types.Unset, str], 'cluster_store': typing.Union[kittycad.types.Unset, str], 'containerd_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'containers': typing.Union[kittycad.types.Unset, int], 'containers_paused': typing.Union[kittycad.types.Unset, int], 'containers_running': typing.Union[kittycad.types.Unset, int], 'containers_stopped': typing.Union[kittycad.types.Unset, int], 'cpu_cfs_period': typing.Union[kittycad.types.Unset, bool], 'cpu_cfs_quota': typing.Union[kittycad.types.Unset, bool], 'cpu_set': typing.Union[kittycad.types.Unset, bool], 'cpu_shares': typing.Union[kittycad.types.Unset, bool], 'debug': typing.Union[kittycad.types.Unset, bool], 'default_address_pools': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools]], 'default_runtime': typing.Union[kittycad.types.Unset, str], 'docker_root_dir': typing.Union[kittycad.types.Unset, str], 'driver': typing.Union[kittycad.types.Unset, str], 'driver_status': typing.Union[kittycad.types.Unset, typing.List[typing.List[str]]], 'experimental_build': typing.Union[kittycad.types.Unset, bool], 'http_proxy': typing.Union[kittycad.types.Unset, str], 'https_proxy': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'images': typing.Union[kittycad.types.Unset, int], 'index_server_address': typing.Union[kittycad.types.Unset, str], 'init_binary': typing.Union[kittycad.types.Unset, str], 'init_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'ipv4_forwarding': typing.Union[kittycad.types.Unset, bool], 'isolation': typing.Union[kittycad.types.Unset, kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum], 'kernel_memory': typing.Union[kittycad.types.Unset, bool], 'kernel_memory_tcp': typing.Union[kittycad.types.Unset, bool], 'kernel_version': typing.Union[kittycad.types.Unset, str], 'labels': typing.Union[kittycad.types.Unset, typing.List[str]], 'live_restore_enabled': typing.Union[kittycad.types.Unset, bool], 'logging_driver': typing.Union[kittycad.types.Unset, str], 'mem_total': typing.Union[kittycad.types.Unset, int], 'memory_limit': typing.Union[kittycad.types.Unset, bool], 'n_events_listener': typing.Union[kittycad.types.Unset, int], 'n_fd': typing.Union[kittycad.types.Unset, int], 'name': typing.Union[kittycad.types.Unset, str], 'ncpu': typing.Union[kittycad.types.Unset, int], 'no_proxy': typing.Union[kittycad.types.Unset, str], 'oom_kill_disable': typing.Union[kittycad.types.Unset, bool], 'operating_system': typing.Union[kittycad.types.Unset, str], 'os_type': typing.Union[kittycad.types.Unset, str], 'os_version': typing.Union[kittycad.types.Unset, str], 'pids_limit': typing.Union[kittycad.types.Unset, bool], 'plugins': typing.Union[kittycad.types.Unset, kittycad.models.plugins_info.PluginsInfo], 'product_license': typing.Union[kittycad.types.Unset, str], 'registry_config': typing.Union[kittycad.types.Unset, kittycad.models.registry_service_config.RegistryServiceConfig], 'runc_commit': typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], 'runtimes': typing.Union[kittycad.types.Unset, typing.Any], 'security_options': typing.Union[kittycad.types.Unset, typing.List[str]], 'server_version': typing.Union[kittycad.types.Unset, str], 'swap_limit': typing.Union[kittycad.types.Unset, bool], 'system_time': typing.Union[kittycad.types.Unset, str], 'warnings': typing.Union[kittycad.types.Unset, typing.List[str]], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Docker system info.', 'SystemInfoDefaultAddressPools': <class 'kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools'>, 'to_dict': <function DockerSystemInfo.to_dict>, 'from_dict': <classmethod(<function DockerSystemInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function DockerSystemInfo.__getitem__>, '__setitem__': <function DockerSystemInfo.__setitem__>, '__delitem__': <function DockerSystemInfo.__delitem__>, '__contains__': <function DockerSystemInfo.__contains__>, '__dict__': <attribute '__dict__' of 'DockerSystemInfo' objects>, '__weakref__': <attribute '__weakref__' of 'DockerSystemInfo' objects>, '__attrs_attrs__': (Attribute(name='architecture', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='architecture'), Attribute(name='bridge_nf_ip6tables', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='bridge_nf_ip6tables'), Attribute(name='bridge_nf_iptables', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='bridge_nf_iptables'), Attribute(name='cgroup_driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cgroup_driver'), Attribute(name='cgroup_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cgroup_version'), Attribute(name='cluster_advertise', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_advertise'), Attribute(name='cluster_store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_store'), Attribute(name='containerd_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containerd_commit'), Attribute(name='containers', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers'), Attribute(name='containers_paused', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_paused'), Attribute(name='containers_running', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_running'), Attribute(name='containers_stopped', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='containers_stopped'), Attribute(name='cpu_cfs_period', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_cfs_period'), Attribute(name='cpu_cfs_quota', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_cfs_quota'), Attribute(name='cpu_set', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_set'), Attribute(name='cpu_shares', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cpu_shares'), Attribute(name='debug', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='debug'), Attribute(name='default_address_pools', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_address_pools'), Attribute(name='default_runtime', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_runtime'), Attribute(name='docker_root_dir', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='docker_root_dir'), Attribute(name='driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='driver'), Attribute(name='driver_status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[typing.List[str]]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='driver_status'), Attribute(name='experimental_build', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='experimental_build'), Attribute(name='http_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='http_proxy'), Attribute(name='https_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='https_proxy'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='images', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='images'), Attribute(name='index_server_address', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='index_server_address'), Attribute(name='init_binary', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='init_binary'), Attribute(name='init_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='init_commit'), Attribute(name='ipv4_forwarding', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ipv4_forwarding'), Attribute(name='isolation', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='isolation'), Attribute(name='kernel_memory', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_memory'), Attribute(name='kernel_memory_tcp', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_memory_tcp'), Attribute(name='kernel_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='kernel_version'), Attribute(name='labels', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='labels'), Attribute(name='live_restore_enabled', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='live_restore_enabled'), Attribute(name='logging_driver', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='logging_driver'), Attribute(name='mem_total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mem_total'), Attribute(name='memory_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='memory_limit'), Attribute(name='n_events_listener', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='n_events_listener'), Attribute(name='n_fd', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='n_fd'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='ncpu', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ncpu'), Attribute(name='no_proxy', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='no_proxy'), Attribute(name='oom_kill_disable', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='oom_kill_disable'), Attribute(name='operating_system', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='operating_system'), Attribute(name='os_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='os_type'), Attribute(name='os_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='os_version'), Attribute(name='pids_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pids_limit'), Attribute(name='plugins', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.plugins_info.PluginsInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='plugins'), Attribute(name='product_license', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='product_license'), Attribute(name='registry_config', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.registry_service_config.RegistryServiceConfig], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='registry_config'), Attribute(name='runc_commit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.commit.Commit], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runc_commit'), Attribute(name='runtimes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runtimes'), Attribute(name='security_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='security_options'), Attribute(name='server_version', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='server_version'), Attribute(name='swap_limit', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='swap_limit'), Attribute(name='system_time', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='system_time'), Attribute(name='warnings', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='warnings'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function DockerSystemInfo.__repr__>, '__eq__': <function DockerSystemInfo.__eq__>, '__ne__': <function DockerSystemInfo.__ne__>, '__lt__': <function DockerSystemInfo.__lt__>, '__le__': <function DockerSystemInfo.__le__>, '__gt__': <function DockerSystemInfo.__gt__>, '__ge__': <function DockerSystemInfo.__ge__>, '__hash__': None, '__init__': <function DockerSystemInfo.__init__>, '__match_args__': ('architecture', 'bridge_nf_ip6tables', 'bridge_nf_iptables', 'cgroup_driver', 'cgroup_version', 'cluster_advertise', 'cluster_store', 'containerd_commit', 'containers', 'containers_paused', 'containers_running', 'containers_stopped', 'cpu_cfs_period', 'cpu_cfs_quota', 'cpu_set', 'cpu_shares', 'debug', 'default_address_pools', 'default_runtime', 'docker_root_dir', 'driver', 'driver_status', 'experimental_build', 'http_proxy', 'https_proxy', 'id', 'images', 'index_server_address', 'init_binary', 'init_commit', 'ipv4_forwarding', 'isolation', 'kernel_memory', 'kernel_memory_tcp', 'kernel_version', 'labels', 'live_restore_enabled', 'logging_driver', 'mem_total', 'memory_limit', 'n_events_listener', 'n_fd', 'name', 'ncpu', 'no_proxy', 'oom_kill_disable', 'operating_system', 'os_type', 'os_version', 'pids_limit', 'plugins', 'product_license', 'registry_config', 'runc_commit', 'runtimes', 'security_options', 'server_version', 'swap_limit', 'system_time', 'warnings')})

__eq__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__ge__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__getitem__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__gt__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__hash__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

__init__() (kittycad.models.docker_system_info.DockerSystemInfo method)

DockerSystemInfo.__init__(architecture=<kittycad.types.Unset object>, bridge_nf_ip6tables=False, bridge_nf_iptables=False, cgroup_driver=<kittycad.types.Unset object>, cgroup_version=<kittycad.types.Unset object>, cluster_advertise=<kittycad.types.Unset object>, cluster_store=<kittycad.types.Unset object>, containerd_commit=<kittycad.types.Unset object>, containers=<kittycad.types.Unset object>, containers_paused=<kittycad.types.Unset object>, containers_running=<kittycad.types.Unset object>, containers_stopped=<kittycad.types.Unset object>, cpu_cfs_period=False, cpu_cfs_quota=False, cpu_set=False, cpu_shares=False, debug=False, default_address_pools=<kittycad.types.Unset object>, default_runtime=<kittycad.types.Unset object>, docker_root_dir=<kittycad.types.Unset object>, driver=<kittycad.types.Unset object>, driver_status=<kittycad.types.Unset object>, experimental_build=False, http_proxy=<kittycad.types.Unset object>, https_proxy=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, images=<kittycad.types.Unset object>, index_server_address=<kittycad.types.Unset object>, init_binary=<kittycad.types.Unset object>, init_commit=<kittycad.types.Unset object>, ipv4_forwarding=False, isolation=<kittycad.types.Unset object>, kernel_memory=False, kernel_memory_tcp=False, kernel_version=<kittycad.types.Unset object>, labels=<kittycad.types.Unset object>, live_restore_enabled=False, logging_driver=<kittycad.types.Unset object>, mem_total=<kittycad.types.Unset object>, memory_limit=False, n_events_listener=<kittycad.types.Unset object>, n_fd=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, ncpu=<kittycad.types.Unset object>, no_proxy=<kittycad.types.Unset object>, oom_kill_disable=False, operating_system=<kittycad.types.Unset object>, os_type=<kittycad.types.Unset object>, os_version=<kittycad.types.Unset object>, pids_limit=False, plugins=<kittycad.types.Unset object>, product_license=<kittycad.types.Unset object>, registry_config=<kittycad.types.Unset object>, runc_commit=<kittycad.types.Unset object>, runtimes=<kittycad.types.Unset object>, security_options=<kittycad.types.Unset object>, server_version=<kittycad.types.Unset object>, swap_limit=False, system_time=<kittycad.types.Unset object>, warnings=<kittycad.types.Unset object>)

__le__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__lt__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__match_args__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

('architecture', 'bridge_nf_ip6tables', 'bridge_nf_iptables', 'cgroup_driver', 'cgroup_version', 'cluster_advertise', 'cluster_store', 'containerd_commit', 'containers', 'containers_paused', 'containers_running', 'containers_stopped', 'cpu_cfs_period', 'cpu_cfs_quota', 'cpu_set', 'cpu_shares', 'debug', 'default_address_pools', 'default_runtime', 'docker_root_dir', 'driver', 'driver_status', 'experimental_build', 'http_proxy', 'https_proxy', 'id', 'images', 'index_server_address', 'init_binary', 'init_commit', 'ipv4_forwarding', 'isolation', 'kernel_memory', 'kernel_memory_tcp', 'kernel_version', 'labels', 'live_restore_enabled', 'logging_driver', 'mem_total', 'memory_limit', 'n_events_listener', 'n_fd', 'name', 'ncpu', 'no_proxy', 'oom_kill_disable', 'operating_system', 'os_type', 'os_version', 'pids_limit', 'plugins', 'product_license', 'registry_config', 'runc_commit', 'runtimes', 'security_options', 'server_version', 'swap_limit', 'system_time', 'warnings')

__module__ (kittycad.models.docker_system_info.DockerSystemInfo attribute)

__ne__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__repr__() (kittycad.models.docker_system_info.DockerSystemInfo method)

__setitem__() (kittycad.models.docker_system_info.DockerSystemInfo method)

additional_keys (kittycad.models.docker_system_info.DockerSystemInfo property)

architecture (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cgroup_driver (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cgroup_version (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cluster_store (kittycad.models.docker_system_info.DockerSystemInfo attribute)

containers (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cpu_cfs_period (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cpu_cfs_quota (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cpu_set (kittycad.models.docker_system_info.DockerSystemInfo attribute)

cpu_shares (kittycad.models.docker_system_info.DockerSystemInfo attribute)

debug (kittycad.models.docker_system_info.DockerSystemInfo attribute)

default_runtime (kittycad.models.docker_system_info.DockerSystemInfo attribute)

docker_root_dir (kittycad.models.docker_system_info.DockerSystemInfo attribute)

driver (kittycad.models.docker_system_info.DockerSystemInfo attribute)

driver_status (kittycad.models.docker_system_info.DockerSystemInfo attribute)

from_dict() (kittycad.models.docker_system_info.DockerSystemInfo class method)

http_proxy (kittycad.models.docker_system_info.DockerSystemInfo attribute)

https_proxy (kittycad.models.docker_system_info.DockerSystemInfo attribute)

id (kittycad.models.docker_system_info.DockerSystemInfo attribute)

images (kittycad.models.docker_system_info.DockerSystemInfo attribute)

init_binary (kittycad.models.docker_system_info.DockerSystemInfo attribute)

init_commit (kittycad.models.docker_system_info.DockerSystemInfo attribute)

ipv4_forwarding (kittycad.models.docker_system_info.DockerSystemInfo attribute)

isolation (kittycad.models.docker_system_info.DockerSystemInfo attribute)

kernel_memory (kittycad.models.docker_system_info.DockerSystemInfo attribute)

kernel_version (kittycad.models.docker_system_info.DockerSystemInfo attribute)

labels (kittycad.models.docker_system_info.DockerSystemInfo attribute)

logging_driver (kittycad.models.docker_system_info.DockerSystemInfo attribute)

mem_total (kittycad.models.docker_system_info.DockerSystemInfo attribute)

memory_limit (kittycad.models.docker_system_info.DockerSystemInfo attribute)

n_fd (kittycad.models.docker_system_info.DockerSystemInfo attribute)

name (kittycad.models.docker_system_info.DockerSystemInfo attribute)

ncpu (kittycad.models.docker_system_info.DockerSystemInfo attribute)

no_proxy (kittycad.models.docker_system_info.DockerSystemInfo attribute)

oom_kill_disable (kittycad.models.docker_system_info.DockerSystemInfo attribute)

operating_system (kittycad.models.docker_system_info.DockerSystemInfo attribute)

os_type (kittycad.models.docker_system_info.DockerSystemInfo attribute)

os_version (kittycad.models.docker_system_info.DockerSystemInfo attribute)

pids_limit (kittycad.models.docker_system_info.DockerSystemInfo attribute)

plugins (kittycad.models.docker_system_info.DockerSystemInfo attribute)

product_license (kittycad.models.docker_system_info.DockerSystemInfo attribute)

registry_config (kittycad.models.docker_system_info.DockerSystemInfo attribute)

runc_commit (kittycad.models.docker_system_info.DockerSystemInfo attribute)

runtimes (kittycad.models.docker_system_info.DockerSystemInfo attribute)

security_options (kittycad.models.docker_system_info.DockerSystemInfo attribute)

server_version (kittycad.models.docker_system_info.DockerSystemInfo attribute)

swap_limit (kittycad.models.docker_system_info.DockerSystemInfo attribute)

system_time (kittycad.models.docker_system_info.DockerSystemInfo attribute)

to_dict() (kittycad.models.docker_system_info.DockerSystemInfo method)

warnings (kittycad.models.docker_system_info.DockerSystemInfo attribute)

__init__([architecture, ...])

Method generated by attrs for class DockerSystemInfo.

rtype

TypeVar(TV, bound= DockerSystemInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.docker_system_info.DockerSystemInfo.__init__>`\ \(\[architecture\, ...\]\)

architecture

bridge_nf_ip6tables

bridge_nf_iptables

cgroup_driver

cgroup_version

cluster_advertise

cluster_store

containerd_commit

containers

containers_paused

containers_running

containers_stopped

cpu_cfs_period

cpu_cfs_quota

cpu_set

cpu_shares

debug

default_address_pools

default_runtime

docker_root_dir

driver

driver_status

experimental_build

http_proxy

https_proxy

id

images

index_server_address

init_binary

init_commit

ipv4_forwarding

isolation

kernel_memory

kernel_memory_tcp

kernel_version

labels

live_restore_enabled

logging_driver

mem_total

memory_limit

n_events_listener

n_fd

name

ncpu

no_proxy

oom_kill_disable

operating_system

os_type

os_version

pids_limit

plugins

product_license

registry_config

runc_commit

runtimes

security_options

server_version

swap_limit

system_time

warnings

EmailAuthenticationForm([callback_url, email])

The body of the form for email authentication.

EmailAuthenticationForm (class in kittycad.models.email_authentication_form)

EmailAuthenticationForm(callback_url=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>)

(callback_url=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'callback_url': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='callback_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='callback_url'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.email_authentication_form', '__annotations__': {'callback_url': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The body of the form for email authentication.', 'to_dict': <function EmailAuthenticationForm.to_dict>, 'from_dict': <classmethod(<function EmailAuthenticationForm.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function EmailAuthenticationForm.__getitem__>, '__setitem__': <function EmailAuthenticationForm.__setitem__>, '__delitem__': <function EmailAuthenticationForm.__delitem__>, '__contains__': <function EmailAuthenticationForm.__contains__>, '__dict__': <attribute '__dict__' of 'EmailAuthenticationForm' objects>, '__weakref__': <attribute '__weakref__' of 'EmailAuthenticationForm' objects>, '__attrs_attrs__': (Attribute(name='callback_url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='callback_url'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function EmailAuthenticationForm.__repr__>, '__eq__': <function EmailAuthenticationForm.__eq__>, '__ne__': <function EmailAuthenticationForm.__ne__>, '__lt__': <function EmailAuthenticationForm.__lt__>, '__le__': <function EmailAuthenticationForm.__le__>, '__gt__': <function EmailAuthenticationForm.__gt__>, '__ge__': <function EmailAuthenticationForm.__ge__>, '__hash__': None, '__init__': <function EmailAuthenticationForm.__init__>, '__match_args__': ('callback_url', 'email')})

EmailAuthenticationForm.__init__(callback_url=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>)

from_dict() (kittycad.models.email_authentication_form.EmailAuthenticationForm class method)

__init__([callback_url, email])

Method generated by attrs for class EmailAuthenticationForm.

rtype

TypeVar(CR, bound= EmailAuthenticationForm)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``CR``, bound= EmailAuthenticationForm)

callback_url

email

EngineMetadata([async_jobs_running, cache, ...])

Metadata about our currently running server.

:py:obj:`EngineMetadata <kittycad.models.engine_metadata.EngineMetadata>`\ \(\[async\_jobs\_running\, cache\, ...\]\)

EngineMetadata(async_jobs_running=False, cache=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

(async_jobs_running=False, cache=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.engine_metadata.EngineMetadata attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'async_jobs_running': typing.Union[kittycad.types.Unset, bool], 'cache': typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'fs': typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], 'git_hash': typing.Union[kittycad.types.Unset, str], 'pubsub': typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection]}

__attrs_attrs__ (kittycad.models.engine_metadata.EngineMetadata attribute)

(Attribute(name='async_jobs_running', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='async_jobs_running'), Attribute(name='cache', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cache'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='fs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fs'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='pubsub', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pubsub'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.engine_metadata.EngineMetadata method)

__delitem__() (kittycad.models.engine_metadata.EngineMetadata method)

__dict__ (kittycad.models.engine_metadata.EngineMetadata attribute)

mappingproxy({'__module__': 'kittycad.models.engine_metadata', '__annotations__': {'async_jobs_running': typing.Union[kittycad.types.Unset, bool], 'cache': typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'fs': typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], 'git_hash': typing.Union[kittycad.types.Unset, str], 'pubsub': typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our currently running server.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function EngineMetadata.to_dict>, 'from_dict': <classmethod(<function EngineMetadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function EngineMetadata.__getitem__>, '__setitem__': <function EngineMetadata.__setitem__>, '__delitem__': <function EngineMetadata.__delitem__>, '__contains__': <function EngineMetadata.__contains__>, '__dict__': <attribute '__dict__' of 'EngineMetadata' objects>, '__weakref__': <attribute '__weakref__' of 'EngineMetadata' objects>, '__attrs_attrs__': (Attribute(name='async_jobs_running', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='async_jobs_running'), Attribute(name='cache', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cache'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='fs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fs'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='pubsub', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pubsub'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function EngineMetadata.__repr__>, '__eq__': <function EngineMetadata.__eq__>, '__ne__': <function EngineMetadata.__ne__>, '__lt__': <function EngineMetadata.__lt__>, '__le__': <function EngineMetadata.__le__>, '__gt__': <function EngineMetadata.__gt__>, '__ge__': <function EngineMetadata.__ge__>, '__hash__': None, '__init__': <function EngineMetadata.__init__>, '__match_args__': ('async_jobs_running', 'cache', 'environment', 'fs', 'git_hash', 'pubsub')})

__eq__() (kittycad.models.engine_metadata.EngineMetadata method)

__ge__() (kittycad.models.engine_metadata.EngineMetadata method)

__getitem__() (kittycad.models.engine_metadata.EngineMetadata method)

__gt__() (kittycad.models.engine_metadata.EngineMetadata method)

__hash__ (kittycad.models.engine_metadata.EngineMetadata attribute)

__init__() (kittycad.models.engine_metadata.EngineMetadata method)

EngineMetadata.__init__(async_jobs_running=False, cache=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

__le__() (kittycad.models.engine_metadata.EngineMetadata method)

__lt__() (kittycad.models.engine_metadata.EngineMetadata method)

__match_args__ (kittycad.models.engine_metadata.EngineMetadata attribute)

('async_jobs_running', 'cache', 'environment', 'fs', 'git_hash', 'pubsub')

__module__ (kittycad.models.engine_metadata.EngineMetadata attribute)

__ne__() (kittycad.models.engine_metadata.EngineMetadata method)

__repr__() (kittycad.models.engine_metadata.EngineMetadata method)

__setitem__() (kittycad.models.engine_metadata.EngineMetadata method)

additional_keys (kittycad.models.engine_metadata.EngineMetadata property)

additional_properties (kittycad.models.engine_metadata.EngineMetadata attribute)

async_jobs_running (kittycad.models.engine_metadata.EngineMetadata attribute)

cache (kittycad.models.engine_metadata.EngineMetadata attribute)

environment (kittycad.models.engine_metadata.EngineMetadata attribute)

from_dict() (kittycad.models.engine_metadata.EngineMetadata class method)

git_hash (kittycad.models.engine_metadata.EngineMetadata attribute)

pubsub (kittycad.models.engine_metadata.EngineMetadata attribute)

to_dict() (kittycad.models.engine_metadata.EngineMetadata method)

__init__([async_jobs_running, cache, ...])

Method generated by attrs for class EngineMetadata.

rtype

TypeVar(CE, bound= EngineMetadata)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.engine_metadata.EngineMetadata.__init__>`\ \(\[async\_jobs\_running\, cache\, ...\]\)

:py:obj:`to_dict <kittycad.models.engine_metadata.EngineMetadata.to_dict>`\ \(\)

async_jobs_running

cache

environment

fs

git_hash

pubsub

EntityType(value[, names, module, qualname, ...])

The type of entity

:py:obj:`EntityType <kittycad.models.entity_type.EntityType>`\ \(value\[\, names\, module\, qualname\, ...\]\)

EntityType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.entity_type.EntityType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.entity_type', '__doc__': 'The type of entity', '__str__': <function EntityType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['ENTITY', 'OBJECT', 'PATH', 'CURVE', 'SOLID2D', 'SOLID3D', 'EDGE', 'FACE'], '_member_map_': {'ENTITY': <EntityType.ENTITY: 'entity'>, 'OBJECT': <EntityType.OBJECT: 'object'>, 'PATH': <EntityType.PATH: 'path'>, 'CURVE': <EntityType.CURVE: 'curve'>, 'SOLID2D': <EntityType.SOLID2D: 'solid2d'>, 'SOLID3D': <EntityType.SOLID3D: 'solid3d'>, 'EDGE': <EntityType.EDGE: 'edge'>, 'FACE': <EntityType.FACE: 'face'>}, '_value2member_map_': {'entity': <EntityType.ENTITY: 'entity'>, 'object': <EntityType.OBJECT: 'object'>, 'path': <EntityType.PATH: 'path'>, 'curve': <EntityType.CURVE: 'curve'>, 'solid2d': <EntityType.SOLID2D: 'solid2d'>, 'solid3d': <EntityType.SOLID3D: 'solid3d'>, 'edge': <EntityType.EDGE: 'edge'>, 'face': <EntityType.FACE: 'face'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'EntityType' objects>, '__weakref__': <attribute '__weakref__' of 'EntityType' objects>, 'ENTITY': <EntityType.ENTITY: 'entity'>, 'OBJECT': <EntityType.OBJECT: 'object'>, 'PATH': <EntityType.PATH: 'path'>, 'CURVE': <EntityType.CURVE: 'curve'>, 'SOLID2D': <EntityType.SOLID2D: 'solid2d'>, 'SOLID3D': <EntityType.SOLID3D: 'solid3d'>, 'EDGE': <EntityType.EDGE: 'edge'>, 'FACE': <EntityType.FACE: 'face'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.entity_type.EntityType method)

__getnewargs__() (kittycad.models.entity_type.EntityType method)

_generate_next_value_() (kittycad.models.entity_type.EntityType method)

{'CURVE': EntityType.CURVE, 'EDGE': EntityType.EDGE, 'ENTITY': EntityType.ENTITY, 'FACE': EntityType.FACE, 'OBJECT': EntityType.OBJECT, 'PATH': EntityType.PATH, 'SOLID2D': EntityType.SOLID2D, 'SOLID3D': EntityType.SOLID3D}

_member_names_ (kittycad.models.entity_type.EntityType attribute)

['ENTITY', 'OBJECT', 'PATH', 'CURVE', 'SOLID2D', 'SOLID3D', 'EDGE', 'FACE']

_member_type_ (kittycad.models.entity_type.EntityType attribute)

_unhashable_values_ (kittycad.models.entity_type.EntityType attribute)

_value2member_map_ (kittycad.models.entity_type.EntityType attribute)

{'curve': EntityType.CURVE, 'edge': EntityType.EDGE, 'entity': EntityType.ENTITY, 'face': EntityType.FACE, 'object': EntityType.OBJECT, 'path': EntityType.PATH, 'solid2d': EntityType.SOLID2D, 'solid3d': EntityType.SOLID3D}

maketrans() (kittycad.models.entity_type.EntityType static method)

:py:obj:`__init__ <kittycad.models.entity_type.EntityType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.entity_type.EntityType.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.entity_type.EntityType.casefold>`\ \(\)

:py:obj:`center <kittycad.models.entity_type.EntityType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.entity_type.EntityType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.entity_type.EntityType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.entity_type.EntityType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.entity_type.EntityType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.entity_type.EntityType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.entity_type.EntityType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.entity_type.EntityType.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.entity_type.EntityType.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.entity_type.EntityType.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.entity_type.EntityType.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.entity_type.EntityType.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.entity_type.EntityType.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.entity_type.EntityType.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.entity_type.EntityType.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.entity_type.EntityType.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.entity_type.EntityType.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.entity_type.EntityType.isupper>`\ \(\)

:py:obj:`join <kittycad.models.entity_type.EntityType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.entity_type.EntityType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.entity_type.EntityType.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.entity_type.EntityType.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.entity_type.EntityType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.entity_type.EntityType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.entity_type.EntityType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.entity_type.EntityType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.entity_type.EntityType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.entity_type.EntityType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.entity_type.EntityType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.entity_type.EntityType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.entity_type.EntityType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.entity_type.EntityType.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.entity_type.EntityType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.entity_type.EntityType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.entity_type.EntityType.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.entity_type.EntityType.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.entity_type.EntityType.title>`\ \(\)

:py:obj:`translate <kittycad.models.entity_type.EntityType.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.entity_type.EntityType.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.entity_type.EntityType.zfill>`\ \(width\, \/\)

ENTITY

OBJECT

PATH

CURVE

SOLID2D

SOLID3D

EDGE

FACE

Environment(value[, names, module, ...])

The environment the server is running in.

:py:obj:`Environment <kittycad.models.environment.Environment>`\ \(value\[\, names\, module\, ...\]\)

Environment(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

docstring of kittycad.models.environment.Environment.DEVELOPMENT

# The preview environment. This is when PRs are created and a service is deployed for testing.

__annotations__ (kittycad.models.environment.Environment attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.environment', '__doc__': 'The environment the server is running in.', '__str__': <function Environment.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['DEVELOPMENT', 'PREVIEW', 'PRODUCTION'], '_member_map_': {'DEVELOPMENT': <Environment.DEVELOPMENT: 'DEVELOPMENT'>, 'PREVIEW': <Environment.PREVIEW: 'PREVIEW'>, 'PRODUCTION': <Environment.PRODUCTION: 'PRODUCTION'>}, '_value2member_map_': {'DEVELOPMENT': <Environment.DEVELOPMENT: 'DEVELOPMENT'>, 'PREVIEW': <Environment.PREVIEW: 'PREVIEW'>, 'PRODUCTION': <Environment.PRODUCTION: 'PRODUCTION'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Environment' objects>, '__weakref__': <attribute '__weakref__' of 'Environment' objects>, 'DEVELOPMENT': <Environment.DEVELOPMENT: 'DEVELOPMENT'>, 'PREVIEW': <Environment.PREVIEW: 'PREVIEW'>, 'PRODUCTION': <Environment.PRODUCTION: 'PRODUCTION'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.environment.Environment method)

__getnewargs__() (kittycad.models.environment.Environment method)

__reduce_ex__() (kittycad.models.environment.Environment method)

_generate_next_value_() (kittycad.models.environment.Environment method)

_member_map_ (kittycad.models.environment.Environment attribute)

{'DEVELOPMENT': Environment.DEVELOPMENT, 'PREVIEW': Environment.PREVIEW, 'PRODUCTION': Environment.PRODUCTION}

_member_names_ (kittycad.models.environment.Environment attribute)

_member_type_ (kittycad.models.environment.Environment attribute)

_unhashable_values_ (kittycad.models.environment.Environment attribute)

_value2member_map_ (kittycad.models.environment.Environment attribute)

maketrans() (kittycad.models.environment.Environment static method)

:py:obj:`__init__ <kittycad.models.environment.Environment.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.environment.Environment.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.environment.Environment.casefold>`\ \(\)

:py:obj:`center <kittycad.models.environment.Environment.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.environment.Environment.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.environment.Environment.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.environment.Environment.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.environment.Environment.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.environment.Environment.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.environment.Environment.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.environment.Environment.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.environment.Environment.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.environment.Environment.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.environment.Environment.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.environment.Environment.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.environment.Environment.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.environment.Environment.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.environment.Environment.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.environment.Environment.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.environment.Environment.isupper>`\ \(\)

:py:obj:`join <kittycad.models.environment.Environment.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.environment.Environment.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.environment.Environment.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.environment.Environment.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.environment.Environment.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.environment.Environment.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.environment.Environment.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.environment.Environment.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.environment.Environment.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.environment.Environment.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.environment.Environment.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.environment.Environment.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.environment.Environment.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.environment.Environment.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.environment.Environment.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.environment.Environment.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.environment.Environment.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.environment.Environment.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.environment.Environment.title>`\ \(\)

:py:obj:`translate <kittycad.models.environment.Environment.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.environment.Environment.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.environment.Environment.zfill>`\ \(width\, \/\)

DEVELOPMENT

# The preview environment.

PREVIEW

# The production environment.

PRODUCTION

Error([error_code, message, request_id])

Error information from a response.

:py:obj:`Error <kittycad.models.error.Error>`\ \(\[error\_code\, message\, request\_id\]\)

Error(error_code=<kittycad.types.Unset object>, message=<kittycad.types.Unset object>, request_id=<kittycad.types.Unset object>)

(error_code=<kittycad.types.Unset object>, message=<kittycad.types.Unset object>, request_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'error_code': typing.Union[kittycad.types.Unset, str], 'message': typing.Union[kittycad.types.Unset, str], 'request_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='error_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error_code'), Attribute(name='message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='message'), Attribute(name='request_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.error', '__annotations__': {'error_code': typing.Union[kittycad.types.Unset, str], 'message': typing.Union[kittycad.types.Unset, str], 'request_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Error information from a response.', 'to_dict': <function Error.to_dict>, 'from_dict': <classmethod(<function Error.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Error.__getitem__>, '__setitem__': <function Error.__setitem__>, '__delitem__': <function Error.__delitem__>, '__contains__': <function Error.__contains__>, '__dict__': <attribute '__dict__' of 'Error' objects>, '__weakref__': <attribute '__weakref__' of 'Error' objects>, '__attrs_attrs__': (Attribute(name='error_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error_code'), Attribute(name='message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='message'), Attribute(name='request_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='request_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Error.__repr__>, '__eq__': <function Error.__eq__>, '__ne__': <function Error.__ne__>, '__lt__': <function Error.__lt__>, '__le__': <function Error.__le__>, '__gt__': <function Error.__gt__>, '__ge__': <function Error.__ge__>, '__hash__': None, '__init__': <function Error.__init__>, '__match_args__': ('error_code', 'message', 'request_id')})

Error.__init__(error_code=<kittycad.types.Unset object>, message=<kittycad.types.Unset object>, request_id=<kittycad.types.Unset object>)

__init__([error_code, message, request_id])

Method generated by attrs for class Error.

rtype

TypeVar(MS, bound= Error)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.error.Error.__init__>`\ \(\[error\_code\, message\, request\_id\]\)

:py:obj:`from_dict <kittycad.models.error.Error.from_dict>`\ \(src\_dict\)

error_code

message

request_id

ExecutorMetadata([docker_info, environment, ...])

:py:obj:`ExecutorMetadata <kittycad.models.executor_metadata.ExecutorMetadata>`\ \(\[docker\_info\, environment\, ...\]\)

ExecutorMetadata(docker_info=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>)

(docker_info=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'docker_info': typing.Union[kittycad.types.Unset, kittycad.models.docker_system_info.DockerSystemInfo], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'git_hash': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

(Attribute(name='docker_info', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.docker_system_info.DockerSystemInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='docker_info'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__delitem__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__dict__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

mappingproxy({'__module__': 'kittycad.models.executor_metadata', '__annotations__': {'docker_info': typing.Union[kittycad.types.Unset, kittycad.models.docker_system_info.DockerSystemInfo], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'git_hash': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our currently running server.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function ExecutorMetadata.to_dict>, 'from_dict': <classmethod(<function ExecutorMetadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ExecutorMetadata.__getitem__>, '__setitem__': <function ExecutorMetadata.__setitem__>, '__delitem__': <function ExecutorMetadata.__delitem__>, '__contains__': <function ExecutorMetadata.__contains__>, '__dict__': <attribute '__dict__' of 'ExecutorMetadata' objects>, '__weakref__': <attribute '__weakref__' of 'ExecutorMetadata' objects>, '__attrs_attrs__': (Attribute(name='docker_info', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.docker_system_info.DockerSystemInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='docker_info'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ExecutorMetadata.__repr__>, '__eq__': <function ExecutorMetadata.__eq__>, '__ne__': <function ExecutorMetadata.__ne__>, '__lt__': <function ExecutorMetadata.__lt__>, '__le__': <function ExecutorMetadata.__le__>, '__gt__': <function ExecutorMetadata.__gt__>, '__ge__': <function ExecutorMetadata.__ge__>, '__hash__': None, '__init__': <function ExecutorMetadata.__init__>, '__match_args__': ('docker_info', 'environment', 'git_hash')})

__eq__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__ge__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__getitem__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__gt__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__hash__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

__init__() (kittycad.models.executor_metadata.ExecutorMetadata method)

ExecutorMetadata.__init__(docker_info=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>)

__le__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__lt__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__match_args__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

__module__ (kittycad.models.executor_metadata.ExecutorMetadata attribute)

__ne__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__repr__() (kittycad.models.executor_metadata.ExecutorMetadata method)

__setitem__() (kittycad.models.executor_metadata.ExecutorMetadata method)

additional_keys (kittycad.models.executor_metadata.ExecutorMetadata property)

docker_info (kittycad.models.executor_metadata.ExecutorMetadata attribute)

environment (kittycad.models.executor_metadata.ExecutorMetadata attribute)

from_dict() (kittycad.models.executor_metadata.ExecutorMetadata class method)

git_hash (kittycad.models.executor_metadata.ExecutorMetadata attribute)

to_dict() (kittycad.models.executor_metadata.ExecutorMetadata method)

__init__([docker_info, environment, git_hash])

Method generated by attrs for class ExecutorMetadata.

rtype

TypeVar(LT, bound= ExecutorMetadata)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.executor_metadata.ExecutorMetadata.__init__>`\ \(\[docker\_info\, environment\, git\_hash\]\)

docker_info

git_hash

ExportFile([contents, name])

A file to be exported to the client.

:py:obj:`ExportFile <kittycad.models.export_file.ExportFile>`\ \(\[contents\, name\]\)

ExportFile(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.export_file.ExportFile attribute)

__attrs_attrs__ (kittycad.models.export_file.ExportFile attribute)

mappingproxy({'__module__': 'kittycad.models.export_file', '__annotations__': {'contents': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file to be exported to the client.', 'to_dict': <function ExportFile.to_dict>, 'from_dict': <classmethod(<function ExportFile.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ExportFile.__getitem__>, '__setitem__': <function ExportFile.__setitem__>, '__delitem__': <function ExportFile.__delitem__>, '__contains__': <function ExportFile.__contains__>, '__dict__': <attribute '__dict__' of 'ExportFile' objects>, '__weakref__': <attribute '__weakref__' of 'ExportFile' objects>, '__attrs_attrs__': (Attribute(name='contents', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='contents'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ExportFile.__repr__>, '__eq__': <function ExportFile.__eq__>, '__ne__': <function ExportFile.__ne__>, '__lt__': <function ExportFile.__lt__>, '__le__': <function ExportFile.__le__>, '__gt__': <function ExportFile.__gt__>, '__ge__': <function ExportFile.__ge__>, '__hash__': None, '__init__': <function ExportFile.__init__>, '__match_args__': ('contents', 'name')})

ExportFile.__init__(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.export_file.ExportFile attribute)

additional_keys (kittycad.models.export_file.ExportFile property)

additional_properties (kittycad.models.export_file.ExportFile attribute)

from_dict() (kittycad.models.export_file.ExportFile class method)

__init__([contents, name])

Method generated by attrs for class ExportFile.

rtype

TypeVar(ED, bound= ExportFile)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.export_file.ExportFile.__init__>`\ \(\[contents\, name\]\)

:py:obj:`to_dict <kittycad.models.export_file.ExportFile.to_dict>`\ \(\)

contents

name

ExtendedUser([company, created_at, discord, ...])

Extended user information.

:py:obj:`ExtendedUser <kittycad.models.extended_user.ExtendedUser>`\ \(\[company\, created\_at\, discord\, ...\]\)

ExtendedUser(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, front_id=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, mailchimp_id=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, stripe_id=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, front_id=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, mailchimp_id=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, stripe_id=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

This is mostly used for internal purposes. It returns a mapping of the user's information, including that of our third party services we use for users: MailChimp, Stripe, and Front

This is mostly used for internal purposes. It returns a mapping of the user’s information, including that of our third party services we use for users: MailChimp, Stripe, and Front

__annotations__ (kittycad.models.extended_user.ExtendedUser attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'company': typing.Union[kittycad.types.Unset, str], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'discord': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str], 'email_verified': typing.Union[kittycad.types.Unset, datetime.datetime], 'first_name': typing.Union[kittycad.types.Unset, str], 'front_id': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'image': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'mailchimp_id': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'stripe_id': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime]}

__attrs_attrs__ (kittycad.models.extended_user.ExtendedUser attribute)

(Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='email_verified', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email_verified'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='front_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='front_id'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='image', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='image'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='mailchimp_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mailchimp_id'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='stripe_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stripe_id'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.extended_user.ExtendedUser method)

__delitem__() (kittycad.models.extended_user.ExtendedUser method)

mappingproxy({'__module__': 'kittycad.models.extended_user', '__annotations__': {'company': typing.Union[kittycad.types.Unset, str], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'discord': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str], 'email_verified': typing.Union[kittycad.types.Unset, datetime.datetime], 'first_name': typing.Union[kittycad.types.Unset, str], 'front_id': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'image': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'mailchimp_id': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'stripe_id': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "Extended user information.\n\n    This is mostly used for internal purposes. It returns a mapping of the user's information, including that of our third party services we use for users: MailChimp, Stripe, and Front\n    ", 'to_dict': <function ExtendedUser.to_dict>, 'from_dict': <classmethod(<function ExtendedUser.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ExtendedUser.__getitem__>, '__setitem__': <function ExtendedUser.__setitem__>, '__delitem__': <function ExtendedUser.__delitem__>, '__contains__': <function ExtendedUser.__contains__>, '__dict__': <attribute '__dict__' of 'ExtendedUser' objects>, '__weakref__': <attribute '__weakref__' of 'ExtendedUser' objects>, '__attrs_attrs__': (Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='email_verified', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email_verified'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='front_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='front_id'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='image', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='image'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='mailchimp_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mailchimp_id'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='stripe_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stripe_id'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ExtendedUser.__repr__>, '__eq__': <function ExtendedUser.__eq__>, '__ne__': <function ExtendedUser.__ne__>, '__lt__': <function ExtendedUser.__lt__>, '__le__': <function ExtendedUser.__le__>, '__gt__': <function ExtendedUser.__gt__>, '__ge__': <function ExtendedUser.__ge__>, '__hash__': None, '__init__': <function ExtendedUser.__init__>, '__match_args__': ('company', 'created_at', 'discord', 'email', 'email_verified', 'first_name', 'front_id', 'github', 'id', 'image', 'last_name', 'mailchimp_id', 'name', 'phone', 'stripe_id', 'updated_at')})

__getitem__() (kittycad.models.extended_user.ExtendedUser method)

ExtendedUser.__init__(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, front_id=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, mailchimp_id=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, stripe_id=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.extended_user.ExtendedUser attribute)

('company', 'created_at', 'discord', 'email', 'email_verified', 'first_name', 'front_id', 'github', 'id', 'image', 'last_name', 'mailchimp_id', 'name', 'phone', 'stripe_id', 'updated_at')

__module__ (kittycad.models.extended_user.ExtendedUser attribute)

__setitem__() (kittycad.models.extended_user.ExtendedUser method)

additional_keys (kittycad.models.extended_user.ExtendedUser property)

additional_properties (kittycad.models.extended_user.ExtendedUser attribute)

created_at (kittycad.models.extended_user.ExtendedUser attribute)

email_verified (kittycad.models.extended_user.ExtendedUser attribute)

first_name (kittycad.models.extended_user.ExtendedUser attribute)

from_dict() (kittycad.models.extended_user.ExtendedUser class method)

last_name (kittycad.models.extended_user.ExtendedUser attribute)

mailchimp_id (kittycad.models.extended_user.ExtendedUser attribute)

stripe_id (kittycad.models.extended_user.ExtendedUser attribute)

updated_at (kittycad.models.extended_user.ExtendedUser attribute)

__init__([company, created_at, discord, ...])

Method generated by attrs for class ExtendedUser.

rtype

TypeVar(YY, bound= ExtendedUser)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.extended_user.ExtendedUser.__init__>`\ \(\[company\, created\_at\, discord\, ...\]\)

:py:obj:`to_dict <kittycad.models.extended_user.ExtendedUser.to_dict>`\ \(\)

company

discord

email

email_verified

first_name

front_id

github

id

image

last_name

mailchimp_id

name

phone

stripe_id

ExtendedUserResultsPage([items, next_page])

ExtendedUserResultsPage (class in kittycad.models.extended_user_results_page)

ExtendedUserResultsPage(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

ExtendedUserResultsPage.ExtendedUser (class in kittycad.models.extended_user_results_page)

ExtendedUserResultsPage.ExtendedUser(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, front_id=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, mailchimp_id=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, stripe_id=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

ExtendedUserResultsPage.ExtendedUser.__init__(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, front_id=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, mailchimp_id=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, stripe_id=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

from_dict() (kittycad.models.extended_user_results_page.ExtendedUserResultsPage.ExtendedUser class method)

{'additional_properties': typing.Dict[str, typing.Any], 'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.extended_user.ExtendedUser]], 'next_page': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.extended_user.ExtendedUser]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.extended_user_results_page', '__annotations__': {'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.extended_user.ExtendedUser]], 'next_page': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A single page of results', 'ExtendedUser': <class 'kittycad.models.extended_user.ExtendedUser'>, 'to_dict': <function ExtendedUserResultsPage.to_dict>, 'from_dict': <classmethod(<function ExtendedUserResultsPage.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ExtendedUserResultsPage.__getitem__>, '__setitem__': <function ExtendedUserResultsPage.__setitem__>, '__delitem__': <function ExtendedUserResultsPage.__delitem__>, '__contains__': <function ExtendedUserResultsPage.__contains__>, '__dict__': <attribute '__dict__' of 'ExtendedUserResultsPage' objects>, '__weakref__': <attribute '__weakref__' of 'ExtendedUserResultsPage' objects>, '__attrs_attrs__': (Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.extended_user.ExtendedUser]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ExtendedUserResultsPage.__repr__>, '__eq__': <function ExtendedUserResultsPage.__eq__>, '__ne__': <function ExtendedUserResultsPage.__ne__>, '__lt__': <function ExtendedUserResultsPage.__lt__>, '__le__': <function ExtendedUserResultsPage.__le__>, '__gt__': <function ExtendedUserResultsPage.__gt__>, '__ge__': <function ExtendedUserResultsPage.__ge__>, '__hash__': None, '__init__': <function ExtendedUserResultsPage.__init__>, '__match_args__': ('items', 'next_page')})

ExtendedUserResultsPage.__init__(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

from_dict() (kittycad.models.extended_user_results_page.ExtendedUserResultsPage class method)

Method generated by attrs for class ExtendedUserResultsPage.

rtype

TypeVar(DO, bound= ExtendedUserResultsPage)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``DO``, bound= ExtendedUserResultsPage)

A file center of mass result.

:py:obj:`FileCenterOfMass <kittycad.models.file_center_of_mass.FileCenterOfMass>`\ \(\[center\_of\_mass\, ...\]\)

FileCenterOfMass(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'center_of_mass': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

(Attribute(name='center_of_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center_of_mass'), Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__delitem__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__dict__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

mappingproxy({'__module__': 'kittycad.models.file_center_of_mass', '__annotations__': {'center_of_mass': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file center of mass result.', 'to_dict': <function FileCenterOfMass.to_dict>, 'from_dict': <classmethod(<function FileCenterOfMass.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileCenterOfMass.__getitem__>, '__setitem__': <function FileCenterOfMass.__setitem__>, '__delitem__': <function FileCenterOfMass.__delitem__>, '__contains__': <function FileCenterOfMass.__contains__>, '__dict__': <attribute '__dict__' of 'FileCenterOfMass' objects>, '__weakref__': <attribute '__weakref__' of 'FileCenterOfMass' objects>, '__attrs_attrs__': (Attribute(name='center_of_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center_of_mass'), Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileCenterOfMass.__repr__>, '__eq__': <function FileCenterOfMass.__eq__>, '__ne__': <function FileCenterOfMass.__ne__>, '__lt__': <function FileCenterOfMass.__lt__>, '__le__': <function FileCenterOfMass.__le__>, '__gt__': <function FileCenterOfMass.__gt__>, '__ge__': <function FileCenterOfMass.__ge__>, '__hash__': None, '__init__': <function FileCenterOfMass.__init__>, '__match_args__': ('center_of_mass', 'completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__ge__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__getitem__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__gt__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__hash__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

__init__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

FileCenterOfMass.__init__(center_of_mass=<kittycad.types.Unset object>, completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__lt__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__match_args__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

('center_of_mass', 'completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')

__module__ (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

__ne__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__repr__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

__setitem__() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

additional_keys (kittycad.models.file_center_of_mass.FileCenterOfMass property)

center_of_mass (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

completed_at (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

created_at (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

error (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

from_dict() (kittycad.models.file_center_of_mass.FileCenterOfMass class method)

id (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

output_unit (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

src_format (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

started_at (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

status (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

to_dict() (kittycad.models.file_center_of_mass.FileCenterOfMass method)

updated_at (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

user_id (kittycad.models.file_center_of_mass.FileCenterOfMass attribute)

rtype

TypeVar(FZ, bound= FileCenterOfMass)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_center_of_mass.FileCenterOfMass.__init__>`\ \(\[center\_of\_mass\, completed\_at\, ...\]\)

error

id

status

user_id

:py:obj:`FileConversion <kittycad.models.file_conversion.FileConversion>`\ \(\[completed\_at\, created\_at\, ...\]\)

FileConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.file_conversion.FileConversion attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output': typing.Union[kittycad.types.Unset, str], 'output_format': typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], 'output_format_options': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'outputs': typing.Union[kittycad.types.Unset, typing.Any], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'src_format_options': typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.file_conversion.FileConversion attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format'), Attribute(name='output_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format_options'), Attribute(name='outputs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outputs'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='src_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format_options'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.file_conversion.FileConversion method)

__delitem__() (kittycad.models.file_conversion.FileConversion method)

__dict__ (kittycad.models.file_conversion.FileConversion attribute)

mappingproxy({'__module__': 'kittycad.models.file_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output': typing.Union[kittycad.types.Unset, str], 'output_format': typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], 'output_format_options': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'outputs': typing.Union[kittycad.types.Unset, typing.Any], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'src_format_options': typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file conversion.', 'to_dict': <function FileConversion.to_dict>, 'from_dict': <classmethod(<function FileConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileConversion.__getitem__>, '__setitem__': <function FileConversion.__setitem__>, '__delitem__': <function FileConversion.__delitem__>, '__contains__': <function FileConversion.__contains__>, '__dict__': <attribute '__dict__' of 'FileConversion' objects>, '__weakref__': <attribute '__weakref__' of 'FileConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_export_format.FileExportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format'), Attribute(name='output_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_format_options'), Attribute(name='outputs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outputs'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='src_format_options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.input_format.gltf, kittycad.models.input_format.step, kittycad.models.input_format.obj, kittycad.models.input_format.ply, kittycad.models.input_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format_options'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileConversion.__repr__>, '__eq__': <function FileConversion.__eq__>, '__ne__': <function FileConversion.__ne__>, '__lt__': <function FileConversion.__lt__>, '__le__': <function FileConversion.__le__>, '__gt__': <function FileConversion.__gt__>, '__ge__': <function FileConversion.__ge__>, '__hash__': None, '__init__': <function FileConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output', 'output_format', 'output_format_options', 'outputs', 'src_format', 'src_format_options', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.file_conversion.FileConversion method)

__ge__() (kittycad.models.file_conversion.FileConversion method)

__getitem__() (kittycad.models.file_conversion.FileConversion method)

__gt__() (kittycad.models.file_conversion.FileConversion method)

__hash__ (kittycad.models.file_conversion.FileConversion attribute)

__init__() (kittycad.models.file_conversion.FileConversion method)

FileConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_format=<kittycad.types.Unset object>, output_format_options=<kittycad.types.Unset object>, outputs=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, src_format_options=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.file_conversion.FileConversion method)

__lt__() (kittycad.models.file_conversion.FileConversion method)

__match_args__ (kittycad.models.file_conversion.FileConversion attribute)

('completed_at', 'created_at', 'error', 'id', 'output', 'output_format', 'output_format_options', 'outputs', 'src_format', 'src_format_options', 'started_at', 'status', 'updated_at', 'user_id')

__module__ (kittycad.models.file_conversion.FileConversion attribute)

__ne__() (kittycad.models.file_conversion.FileConversion method)

__repr__() (kittycad.models.file_conversion.FileConversion method)

__setitem__() (kittycad.models.file_conversion.FileConversion method)

additional_keys (kittycad.models.file_conversion.FileConversion property)

additional_properties (kittycad.models.file_conversion.FileConversion attribute)

completed_at (kittycad.models.file_conversion.FileConversion attribute)

created_at (kittycad.models.file_conversion.FileConversion attribute)

error (kittycad.models.file_conversion.FileConversion attribute)

from_dict() (kittycad.models.file_conversion.FileConversion class method)

output (kittycad.models.file_conversion.FileConversion attribute)

output_format (kittycad.models.file_conversion.FileConversion attribute)

output_format_options (kittycad.models.file_conversion.FileConversion attribute)

outputs (kittycad.models.file_conversion.FileConversion attribute)

src_format (kittycad.models.file_conversion.FileConversion attribute)

src_format_options (kittycad.models.file_conversion.FileConversion attribute)

started_at (kittycad.models.file_conversion.FileConversion attribute)

status (kittycad.models.file_conversion.FileConversion attribute)

to_dict() (kittycad.models.file_conversion.FileConversion method)

updated_at (kittycad.models.file_conversion.FileConversion attribute)

user_id (kittycad.models.file_conversion.FileConversion attribute)

rtype

TypeVar(GL, bound= FileConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_conversion.FileConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`to_dict <kittycad.models.file_conversion.FileConversion.to_dict>`\ \(\)

error

id

output

outputs

status

user_id

A file density result.

:py:obj:`FileDensity <kittycad.models.file_density.FileDensity>`\ \(\[completed\_at\, created\_at\, ...\]\)

FileDensity(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.file_density.FileDensity attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'density': typing.Union[kittycad.types.Unset, float], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'material_mass': typing.Union[kittycad.types.Unset, float], 'material_mass_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.file_density.FileDensity attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='density'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='material_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass'), Attribute(name='material_mass_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.file_density.FileDensity method)

mappingproxy({'__module__': 'kittycad.models.file_density', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'density': typing.Union[kittycad.types.Unset, float], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'material_mass': typing.Union[kittycad.types.Unset, float], 'material_mass_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file density result.', 'to_dict': <function FileDensity.to_dict>, 'from_dict': <classmethod(<function FileDensity.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileDensity.__getitem__>, '__setitem__': <function FileDensity.__setitem__>, '__delitem__': <function FileDensity.__delitem__>, '__contains__': <function FileDensity.__contains__>, '__dict__': <attribute '__dict__' of 'FileDensity' objects>, '__weakref__': <attribute '__weakref__' of 'FileDensity' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='density'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='material_mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass'), Attribute(name='material_mass_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_mass_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileDensity.__repr__>, '__eq__': <function FileDensity.__eq__>, '__ne__': <function FileDensity.__ne__>, '__lt__': <function FileDensity.__lt__>, '__le__': <function FileDensity.__le__>, '__gt__': <function FileDensity.__gt__>, '__ge__': <function FileDensity.__ge__>, '__hash__': None, '__init__': <function FileDensity.__init__>, '__match_args__': ('completed_at', 'created_at', 'density', 'error', 'id', 'material_mass', 'material_mass_unit', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')})

FileDensity.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, density=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, material_mass=<kittycad.types.Unset object>, material_mass_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.file_density.FileDensity attribute)

('completed_at', 'created_at', 'density', 'error', 'id', 'material_mass', 'material_mass_unit', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')

additional_keys (kittycad.models.file_density.FileDensity property)

additional_properties (kittycad.models.file_density.FileDensity attribute)

completed_at (kittycad.models.file_density.FileDensity attribute)

from_dict() (kittycad.models.file_density.FileDensity class method)

material_mass (kittycad.models.file_density.FileDensity attribute)

material_mass_unit (kittycad.models.file_density.FileDensity attribute)

output_unit (kittycad.models.file_density.FileDensity attribute)

rtype

TypeVar(NN, bound= FileDensity)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_density.FileDensity.__init__>`\ \(\[completed\_at\, created\_at\, ...\]\)

:py:obj:`to_dict <kittycad.models.file_density.FileDensity.to_dict>`\ \(\)

density

error

id

status

user_id

FileExportFormat(value[, names, module, ...])

The valid types of output file formats.

:py:obj:`FileExportFormat <kittycad.models.file_export_format.FileExportFormat>`\ \(value\[\, names\, module\, ...\]\)

FileExportFormat(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

GLTF (kittycad.models.file_export_format.FileExportFormat attribute)

//en.wikipedia.org/wiki/Wavefront_.obj_file> It may or may not have an an attached material (mtl // mtllib) within the file, but we interact with it as if it does not.

.obj_file> It may or may not have an an attached material (mtl // mtllib) within the file, but we interact with it as if it does not.

docstring of kittycad.models.file_export_format.FileExportFormat.GLTF

OBJ (kittycad.models.file_export_format.FileExportFormat attribute)

docstring of kittycad.models.file_export_format.FileExportFormat.OBJ

PLY (kittycad.models.file_export_format.FileExportFormat attribute)

docstring of kittycad.models.file_export_format.FileExportFormat.PLY

STEP (kittycad.models.file_export_format.FileExportFormat attribute)

docstring of kittycad.models.file_export_format.FileExportFormat.STEP

STL (kittycad.models.file_export_format.FileExportFormat attribute)

__add__() (kittycad.models.file_export_format.FileExportFormat method)

__annotations__ (kittycad.models.file_export_format.FileExportFormat attribute)

__contains__() (kittycad.models.file_export_format.FileExportFormat method)

__dict__ (kittycad.models.file_export_format.FileExportFormat attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.file_export_format', '__doc__': 'The valid types of output file formats.', '__str__': <function FileExportFormat.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['GLTF', 'OBJ', 'PLY', 'STEP', 'STL'], '_member_map_': {'GLTF': <FileExportFormat.GLTF: 'gltf'>, 'OBJ': <FileExportFormat.OBJ: 'obj'>, 'PLY': <FileExportFormat.PLY: 'ply'>, 'STEP': <FileExportFormat.STEP: 'step'>, 'STL': <FileExportFormat.STL: 'stl'>}, '_value2member_map_': {'gltf': <FileExportFormat.GLTF: 'gltf'>, 'obj': <FileExportFormat.OBJ: 'obj'>, 'ply': <FileExportFormat.PLY: 'ply'>, 'step': <FileExportFormat.STEP: 'step'>, 'stl': <FileExportFormat.STL: 'stl'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'FileExportFormat' objects>, '__weakref__': <attribute '__weakref__' of 'FileExportFormat' objects>, 'GLTF': <FileExportFormat.GLTF: 'gltf'>, 'OBJ': <FileExportFormat.OBJ: 'obj'>, 'PLY': <FileExportFormat.PLY: 'ply'>, 'STEP': <FileExportFormat.STEP: 'step'>, 'STL': <FileExportFormat.STL: 'stl'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.file_export_format.FileExportFormat method)

__eq__() (kittycad.models.file_export_format.FileExportFormat method)

__format__() (kittycad.models.file_export_format.FileExportFormat method)

__ge__() (kittycad.models.file_export_format.FileExportFormat method)

__getattribute__() (kittycad.models.file_export_format.FileExportFormat method)

__getitem__() (kittycad.models.file_export_format.FileExportFormat method)

__getnewargs__() (kittycad.models.file_export_format.FileExportFormat method)

__gt__() (kittycad.models.file_export_format.FileExportFormat method)

__hash__() (kittycad.models.file_export_format.FileExportFormat method)

__init__() (kittycad.models.file_export_format.FileExportFormat method)

__iter__() (kittycad.models.file_export_format.FileExportFormat method)

__le__() (kittycad.models.file_export_format.FileExportFormat method)

__len__() (kittycad.models.file_export_format.FileExportFormat method)

__lt__() (kittycad.models.file_export_format.FileExportFormat method)

__mod__() (kittycad.models.file_export_format.FileExportFormat method)

__module__ (kittycad.models.file_export_format.FileExportFormat attribute)

__mul__() (kittycad.models.file_export_format.FileExportFormat method)

__ne__() (kittycad.models.file_export_format.FileExportFormat method)

__new__() (kittycad.models.file_export_format.FileExportFormat method)

__reduce_ex__() (kittycad.models.file_export_format.FileExportFormat method)

__repr__() (kittycad.models.file_export_format.FileExportFormat method)

__rmod__() (kittycad.models.file_export_format.FileExportFormat method)

__rmul__() (kittycad.models.file_export_format.FileExportFormat method)

__sizeof__() (kittycad.models.file_export_format.FileExportFormat method)

__str__() (kittycad.models.file_export_format.FileExportFormat method)

FileExportFormat._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.file_export_format.FileExportFormat attribute)

{'GLTF': FileExportFormat.GLTF, 'OBJ': FileExportFormat.OBJ, 'PLY': FileExportFormat.PLY, 'STEP': FileExportFormat.STEP, 'STL': FileExportFormat.STL}

_member_names_ (kittycad.models.file_export_format.FileExportFormat attribute)

_member_type_ (kittycad.models.file_export_format.FileExportFormat attribute)

_new_member_() (kittycad.models.file_export_format.FileExportFormat method)

_use_args_ (kittycad.models.file_export_format.FileExportFormat attribute)

{'gltf': FileExportFormat.GLTF, 'obj': FileExportFormat.OBJ, 'ply': FileExportFormat.PLY, 'step': FileExportFormat.STEP, 'stl': FileExportFormat.STL}

_value_repr_() (kittycad.models.file_export_format.FileExportFormat method)

capitalize() (kittycad.models.file_export_format.FileExportFormat method)

casefold() (kittycad.models.file_export_format.FileExportFormat method)

center() (kittycad.models.file_export_format.FileExportFormat method)

count() (kittycad.models.file_export_format.FileExportFormat method)

encode() (kittycad.models.file_export_format.FileExportFormat method)

endswith() (kittycad.models.file_export_format.FileExportFormat method)

expandtabs() (kittycad.models.file_export_format.FileExportFormat method)

find() (kittycad.models.file_export_format.FileExportFormat method)

format() (kittycad.models.file_export_format.FileExportFormat method)

format_map() (kittycad.models.file_export_format.FileExportFormat method)

index() (kittycad.models.file_export_format.FileExportFormat method)

isalnum() (kittycad.models.file_export_format.FileExportFormat method)

isalpha() (kittycad.models.file_export_format.FileExportFormat method)

isascii() (kittycad.models.file_export_format.FileExportFormat method)

isdecimal() (kittycad.models.file_export_format.FileExportFormat method)

isdigit() (kittycad.models.file_export_format.FileExportFormat method)

isidentifier() (kittycad.models.file_export_format.FileExportFormat method)

islower() (kittycad.models.file_export_format.FileExportFormat method)

isnumeric() (kittycad.models.file_export_format.FileExportFormat method)

isprintable() (kittycad.models.file_export_format.FileExportFormat method)

isspace() (kittycad.models.file_export_format.FileExportFormat method)

istitle() (kittycad.models.file_export_format.FileExportFormat method)

isupper() (kittycad.models.file_export_format.FileExportFormat method)

join() (kittycad.models.file_export_format.FileExportFormat method)

ljust() (kittycad.models.file_export_format.FileExportFormat method)

lower() (kittycad.models.file_export_format.FileExportFormat method)

lstrip() (kittycad.models.file_export_format.FileExportFormat method)

maketrans() (kittycad.models.file_export_format.FileExportFormat static method)

partition() (kittycad.models.file_export_format.FileExportFormat method)

removeprefix() (kittycad.models.file_export_format.FileExportFormat method)

removesuffix() (kittycad.models.file_export_format.FileExportFormat method)

replace() (kittycad.models.file_export_format.FileExportFormat method)

rfind() (kittycad.models.file_export_format.FileExportFormat method)

rindex() (kittycad.models.file_export_format.FileExportFormat method)

rjust() (kittycad.models.file_export_format.FileExportFormat method)

rpartition() (kittycad.models.file_export_format.FileExportFormat method)

rsplit() (kittycad.models.file_export_format.FileExportFormat method)

rstrip() (kittycad.models.file_export_format.FileExportFormat method)

split() (kittycad.models.file_export_format.FileExportFormat method)

splitlines() (kittycad.models.file_export_format.FileExportFormat method)

startswith() (kittycad.models.file_export_format.FileExportFormat method)

strip() (kittycad.models.file_export_format.FileExportFormat method)

swapcase() (kittycad.models.file_export_format.FileExportFormat method)

title() (kittycad.models.file_export_format.FileExportFormat method)

translate() (kittycad.models.file_export_format.FileExportFormat method)

upper() (kittycad.models.file_export_format.FileExportFormat method)

zfill() (kittycad.models.file_export_format.FileExportFormat method)

:py:obj:`__init__ <kittycad.models.file_export_format.FileExportFormat.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.file_export_format.FileExportFormat.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.file_export_format.FileExportFormat.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.file_export_format.FileExportFormat.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.file_export_format.FileExportFormat.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.file_export_format.FileExportFormat.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.file_export_format.FileExportFormat.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.file_export_format.FileExportFormat.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.file_export_format.FileExportFormat.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.file_export_format.FileExportFormat.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.file_export_format.FileExportFormat.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.file_export_format.FileExportFormat.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.file_export_format.FileExportFormat.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.file_export_format.FileExportFormat.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.file_export_format.FileExportFormat.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.file_export_format.FileExportFormat.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.file_export_format.FileExportFormat.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.file_export_format.FileExportFormat.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.file_export_format.FileExportFormat.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.file_export_format.FileExportFormat.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.file_export_format.FileExportFormat.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.file_export_format.FileExportFormat.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.file_export_format.FileExportFormat.zfill>`\ \(width\, \/\)

GLTF

//en.wikipedia.org/wiki/Wavefront.obj_file> It may or may not have an an attached material (mtl // mtllib) within the file, but we interact with it as if it does not.

OBJ

//en.wikipedia.org/wiki/PLY_(file_format)>

PLY

//en.wikipedia.org/wiki/ISO_10303-21>

STEP

//en.wikipedia.org/wiki/STL_(file_format)>

STL

FileImportFormat(value[, names, module, ...])

The valid types of source file formats.

:py:obj:`FileImportFormat <kittycad.models.file_import_format.FileImportFormat>`\ \(value\[\, names\, module\, ...\]\)

FileImportFormat(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

GLTF (kittycad.models.file_import_format.FileImportFormat attribute)

docstring of kittycad.models.file_import_format.FileImportFormat.GLTF

OBJ (kittycad.models.file_import_format.FileImportFormat attribute)

docstring of kittycad.models.file_import_format.FileImportFormat.OBJ

PLY (kittycad.models.file_import_format.FileImportFormat attribute)

docstring of kittycad.models.file_import_format.FileImportFormat.PLY

STEP (kittycad.models.file_import_format.FileImportFormat attribute)

docstring of kittycad.models.file_import_format.FileImportFormat.STEP

STL (kittycad.models.file_import_format.FileImportFormat attribute)

__add__() (kittycad.models.file_import_format.FileImportFormat method)

__annotations__ (kittycad.models.file_import_format.FileImportFormat attribute)

__contains__() (kittycad.models.file_import_format.FileImportFormat method)

__dict__ (kittycad.models.file_import_format.FileImportFormat attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.file_import_format', '__doc__': 'The valid types of source file formats.', '__str__': <function FileImportFormat.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['GLTF', 'OBJ', 'PLY', 'STEP', 'STL'], '_member_map_': {'GLTF': <FileImportFormat.GLTF: 'gltf'>, 'OBJ': <FileImportFormat.OBJ: 'obj'>, 'PLY': <FileImportFormat.PLY: 'ply'>, 'STEP': <FileImportFormat.STEP: 'step'>, 'STL': <FileImportFormat.STL: 'stl'>}, '_value2member_map_': {'gltf': <FileImportFormat.GLTF: 'gltf'>, 'obj': <FileImportFormat.OBJ: 'obj'>, 'ply': <FileImportFormat.PLY: 'ply'>, 'step': <FileImportFormat.STEP: 'step'>, 'stl': <FileImportFormat.STL: 'stl'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'FileImportFormat' objects>, '__weakref__': <attribute '__weakref__' of 'FileImportFormat' objects>, 'GLTF': <FileImportFormat.GLTF: 'gltf'>, 'OBJ': <FileImportFormat.OBJ: 'obj'>, 'PLY': <FileImportFormat.PLY: 'ply'>, 'STEP': <FileImportFormat.STEP: 'step'>, 'STL': <FileImportFormat.STL: 'stl'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.file_import_format.FileImportFormat method)

__eq__() (kittycad.models.file_import_format.FileImportFormat method)

__format__() (kittycad.models.file_import_format.FileImportFormat method)

__ge__() (kittycad.models.file_import_format.FileImportFormat method)

__getattribute__() (kittycad.models.file_import_format.FileImportFormat method)

__getitem__() (kittycad.models.file_import_format.FileImportFormat method)

__getnewargs__() (kittycad.models.file_import_format.FileImportFormat method)

__gt__() (kittycad.models.file_import_format.FileImportFormat method)

__hash__() (kittycad.models.file_import_format.FileImportFormat method)

__init__() (kittycad.models.file_import_format.FileImportFormat method)

__iter__() (kittycad.models.file_import_format.FileImportFormat method)

__le__() (kittycad.models.file_import_format.FileImportFormat method)

__len__() (kittycad.models.file_import_format.FileImportFormat method)

__lt__() (kittycad.models.file_import_format.FileImportFormat method)

__mod__() (kittycad.models.file_import_format.FileImportFormat method)

__module__ (kittycad.models.file_import_format.FileImportFormat attribute)

__mul__() (kittycad.models.file_import_format.FileImportFormat method)

__ne__() (kittycad.models.file_import_format.FileImportFormat method)

__new__() (kittycad.models.file_import_format.FileImportFormat method)

__reduce_ex__() (kittycad.models.file_import_format.FileImportFormat method)

__repr__() (kittycad.models.file_import_format.FileImportFormat method)

__rmod__() (kittycad.models.file_import_format.FileImportFormat method)

__rmul__() (kittycad.models.file_import_format.FileImportFormat method)

__sizeof__() (kittycad.models.file_import_format.FileImportFormat method)

__str__() (kittycad.models.file_import_format.FileImportFormat method)

FileImportFormat._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.file_import_format.FileImportFormat attribute)

{'GLTF': FileImportFormat.GLTF, 'OBJ': FileImportFormat.OBJ, 'PLY': FileImportFormat.PLY, 'STEP': FileImportFormat.STEP, 'STL': FileImportFormat.STL}

_member_names_ (kittycad.models.file_import_format.FileImportFormat attribute)

_member_type_ (kittycad.models.file_import_format.FileImportFormat attribute)

_new_member_() (kittycad.models.file_import_format.FileImportFormat method)

_use_args_ (kittycad.models.file_import_format.FileImportFormat attribute)

{'gltf': FileImportFormat.GLTF, 'obj': FileImportFormat.OBJ, 'ply': FileImportFormat.PLY, 'step': FileImportFormat.STEP, 'stl': FileImportFormat.STL}

_value_repr_() (kittycad.models.file_import_format.FileImportFormat method)

capitalize() (kittycad.models.file_import_format.FileImportFormat method)

casefold() (kittycad.models.file_import_format.FileImportFormat method)

center() (kittycad.models.file_import_format.FileImportFormat method)

count() (kittycad.models.file_import_format.FileImportFormat method)

encode() (kittycad.models.file_import_format.FileImportFormat method)

endswith() (kittycad.models.file_import_format.FileImportFormat method)

expandtabs() (kittycad.models.file_import_format.FileImportFormat method)

find() (kittycad.models.file_import_format.FileImportFormat method)

format() (kittycad.models.file_import_format.FileImportFormat method)

format_map() (kittycad.models.file_import_format.FileImportFormat method)

index() (kittycad.models.file_import_format.FileImportFormat method)

isalnum() (kittycad.models.file_import_format.FileImportFormat method)

isalpha() (kittycad.models.file_import_format.FileImportFormat method)

isascii() (kittycad.models.file_import_format.FileImportFormat method)

isdecimal() (kittycad.models.file_import_format.FileImportFormat method)

isdigit() (kittycad.models.file_import_format.FileImportFormat method)

isidentifier() (kittycad.models.file_import_format.FileImportFormat method)

islower() (kittycad.models.file_import_format.FileImportFormat method)

isnumeric() (kittycad.models.file_import_format.FileImportFormat method)

isprintable() (kittycad.models.file_import_format.FileImportFormat method)

isspace() (kittycad.models.file_import_format.FileImportFormat method)

istitle() (kittycad.models.file_import_format.FileImportFormat method)

isupper() (kittycad.models.file_import_format.FileImportFormat method)

join() (kittycad.models.file_import_format.FileImportFormat method)

ljust() (kittycad.models.file_import_format.FileImportFormat method)

lower() (kittycad.models.file_import_format.FileImportFormat method)

lstrip() (kittycad.models.file_import_format.FileImportFormat method)

maketrans() (kittycad.models.file_import_format.FileImportFormat static method)

partition() (kittycad.models.file_import_format.FileImportFormat method)

removeprefix() (kittycad.models.file_import_format.FileImportFormat method)

removesuffix() (kittycad.models.file_import_format.FileImportFormat method)

replace() (kittycad.models.file_import_format.FileImportFormat method)

rfind() (kittycad.models.file_import_format.FileImportFormat method)

rindex() (kittycad.models.file_import_format.FileImportFormat method)

rjust() (kittycad.models.file_import_format.FileImportFormat method)

rpartition() (kittycad.models.file_import_format.FileImportFormat method)

rsplit() (kittycad.models.file_import_format.FileImportFormat method)

rstrip() (kittycad.models.file_import_format.FileImportFormat method)

split() (kittycad.models.file_import_format.FileImportFormat method)

splitlines() (kittycad.models.file_import_format.FileImportFormat method)

startswith() (kittycad.models.file_import_format.FileImportFormat method)

strip() (kittycad.models.file_import_format.FileImportFormat method)

swapcase() (kittycad.models.file_import_format.FileImportFormat method)

title() (kittycad.models.file_import_format.FileImportFormat method)

translate() (kittycad.models.file_import_format.FileImportFormat method)

upper() (kittycad.models.file_import_format.FileImportFormat method)

zfill() (kittycad.models.file_import_format.FileImportFormat method)

:py:obj:`__init__ <kittycad.models.file_import_format.FileImportFormat.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.file_import_format.FileImportFormat.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.file_import_format.FileImportFormat.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.file_import_format.FileImportFormat.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.file_import_format.FileImportFormat.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.file_import_format.FileImportFormat.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.file_import_format.FileImportFormat.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.file_import_format.FileImportFormat.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.file_import_format.FileImportFormat.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.file_import_format.FileImportFormat.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.file_import_format.FileImportFormat.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.file_import_format.FileImportFormat.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.file_import_format.FileImportFormat.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.file_import_format.FileImportFormat.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.file_import_format.FileImportFormat.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.file_import_format.FileImportFormat.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.file_import_format.FileImportFormat.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.file_import_format.FileImportFormat.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.file_import_format.FileImportFormat.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.file_import_format.FileImportFormat.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.file_import_format.FileImportFormat.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.file_import_format.FileImportFormat.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.file_import_format.FileImportFormat.zfill>`\ \(width\, \/\)

A file mass result.

:py:obj:`FileMass <kittycad.models.file_mass.FileMass>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

FileMass(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'mass': typing.Union[kittycad.types.Unset, float], 'material_density': typing.Union[kittycad.types.Unset, float], 'material_density_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mass'), Attribute(name='material_density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density'), Attribute(name='material_density_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.file_mass', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'mass': typing.Union[kittycad.types.Unset, float], 'material_density': typing.Union[kittycad.types.Unset, float], 'material_density_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file mass result.', 'to_dict': <function FileMass.to_dict>, 'from_dict': <classmethod(<function FileMass.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileMass.__getitem__>, '__setitem__': <function FileMass.__setitem__>, '__delitem__': <function FileMass.__delitem__>, '__contains__': <function FileMass.__contains__>, '__dict__': <attribute '__dict__' of 'FileMass' objects>, '__weakref__': <attribute '__weakref__' of 'FileMass' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='mass', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mass'), Attribute(name='material_density', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density'), Attribute(name='material_density_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_density.UnitDensity], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='material_density_unit'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileMass.__repr__>, '__eq__': <function FileMass.__eq__>, '__ne__': <function FileMass.__ne__>, '__lt__': <function FileMass.__lt__>, '__le__': <function FileMass.__le__>, '__gt__': <function FileMass.__gt__>, '__ge__': <function FileMass.__ge__>, '__hash__': None, '__init__': <function FileMass.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'mass', 'material_density', 'material_density_unit', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')})

FileMass.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, mass=<kittycad.types.Unset object>, material_density=<kittycad.types.Unset object>, material_density_unit=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

('completed_at', 'created_at', 'error', 'id', 'mass', 'material_density', 'material_density_unit', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id')

additional_properties (kittycad.models.file_mass.FileMass attribute)

material_density_unit (kittycad.models.file_mass.FileMass attribute)

rtype

TypeVar(OH, bound= FileMass)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_mass.FileMass.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`to_dict <kittycad.models.file_mass.FileMass.to_dict>`\ \(\)

error

id

mass

status

user_id

A file surface area result.

:py:obj:`FileSurfaceArea <kittycad.models.file_surface_area.FileSurfaceArea>`\ \(\[completed\_at\, created\_at\, ...\]\)

FileSurfaceArea(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'surface_area': typing.Union[kittycad.types.Unset, float], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='surface_area', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='surface_area'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__delitem__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__dict__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

mappingproxy({'__module__': 'kittycad.models.file_surface_area', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'surface_area': typing.Union[kittycad.types.Unset, float], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file surface area result.', 'to_dict': <function FileSurfaceArea.to_dict>, 'from_dict': <classmethod(<function FileSurfaceArea.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileSurfaceArea.__getitem__>, '__setitem__': <function FileSurfaceArea.__setitem__>, '__delitem__': <function FileSurfaceArea.__delitem__>, '__contains__': <function FileSurfaceArea.__contains__>, '__dict__': <attribute '__dict__' of 'FileSurfaceArea' objects>, '__weakref__': <attribute '__weakref__' of 'FileSurfaceArea' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='surface_area', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='surface_area'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileSurfaceArea.__repr__>, '__eq__': <function FileSurfaceArea.__eq__>, '__ne__': <function FileSurfaceArea.__ne__>, '__lt__': <function FileSurfaceArea.__lt__>, '__le__': <function FileSurfaceArea.__le__>, '__gt__': <function FileSurfaceArea.__gt__>, '__ge__': <function FileSurfaceArea.__ge__>, '__hash__': None, '__init__': <function FileSurfaceArea.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'surface_area', 'updated_at', 'user_id')})

__eq__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__ge__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__getitem__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__gt__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__hash__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

__init__() (kittycad.models.file_surface_area.FileSurfaceArea method)

FileSurfaceArea.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, surface_area=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__lt__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__match_args__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'surface_area', 'updated_at', 'user_id')

__module__ (kittycad.models.file_surface_area.FileSurfaceArea attribute)

__ne__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__repr__() (kittycad.models.file_surface_area.FileSurfaceArea method)

__setitem__() (kittycad.models.file_surface_area.FileSurfaceArea method)

additional_keys (kittycad.models.file_surface_area.FileSurfaceArea property)

completed_at (kittycad.models.file_surface_area.FileSurfaceArea attribute)

created_at (kittycad.models.file_surface_area.FileSurfaceArea attribute)

error (kittycad.models.file_surface_area.FileSurfaceArea attribute)

from_dict() (kittycad.models.file_surface_area.FileSurfaceArea class method)

id (kittycad.models.file_surface_area.FileSurfaceArea attribute)

output_unit (kittycad.models.file_surface_area.FileSurfaceArea attribute)

src_format (kittycad.models.file_surface_area.FileSurfaceArea attribute)

started_at (kittycad.models.file_surface_area.FileSurfaceArea attribute)

status (kittycad.models.file_surface_area.FileSurfaceArea attribute)

surface_area (kittycad.models.file_surface_area.FileSurfaceArea attribute)

to_dict() (kittycad.models.file_surface_area.FileSurfaceArea method)

updated_at (kittycad.models.file_surface_area.FileSurfaceArea attribute)

user_id (kittycad.models.file_surface_area.FileSurfaceArea attribute)

rtype

TypeVar(VI, bound= FileSurfaceArea)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_surface_area.FileSurfaceArea.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

error

id

status

user_id

FileSystemMetadata (class in kittycad.models.file_system_metadata)

__contains__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__delitem__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__dict__ (kittycad.models.file_system_metadata.FileSystemMetadata attribute)

mappingproxy({'__module__': 'kittycad.models.file_system_metadata', '__annotations__': {'ok': typing.Union[kittycad.types.Unset, bool], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our file system.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function FileSystemMetadata.to_dict>, 'from_dict': <classmethod(<function FileSystemMetadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileSystemMetadata.__getitem__>, '__setitem__': <function FileSystemMetadata.__setitem__>, '__delitem__': <function FileSystemMetadata.__delitem__>, '__contains__': <function FileSystemMetadata.__contains__>, '__dict__': <attribute '__dict__' of 'FileSystemMetadata' objects>, '__weakref__': <attribute '__weakref__' of 'FileSystemMetadata' objects>, '__attrs_attrs__': (Attribute(name='ok', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ok'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileSystemMetadata.__repr__>, '__eq__': <function FileSystemMetadata.__eq__>, '__ne__': <function FileSystemMetadata.__ne__>, '__lt__': <function FileSystemMetadata.__lt__>, '__le__': <function FileSystemMetadata.__le__>, '__gt__': <function FileSystemMetadata.__gt__>, '__ge__': <function FileSystemMetadata.__ge__>, '__hash__': None, '__init__': <function FileSystemMetadata.__init__>, '__match_args__': ('ok',)})

__eq__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__ge__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__getitem__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__gt__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__hash__ (kittycad.models.file_system_metadata.FileSystemMetadata attribute)

__init__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__le__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__lt__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__module__ (kittycad.models.file_system_metadata.FileSystemMetadata attribute)

__ne__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__repr__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

__setitem__() (kittycad.models.file_system_metadata.FileSystemMetadata method)

from_dict() (kittycad.models.file_system_metadata.FileSystemMetadata class method)

ok (kittycad.models.file_system_metadata.FileSystemMetadata attribute)

to_dict() (kittycad.models.file_system_metadata.FileSystemMetadata method)

Method generated by attrs for class FileSystemMetadata.

rtype

TypeVar(ET, bound= FileSystemMetadata)

to_dict()

rtype

A file volume result.

:py:obj:`FileVolume <kittycad.models.file_volume.FileVolume>`\ \(\[completed\_at\, created\_at\, ...\]\)

FileVolume(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.file_volume.FileVolume attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'volume': typing.Union[kittycad.types.Unset, float]}

__attrs_attrs__ (kittycad.models.file_volume.FileVolume attribute)

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.file_volume', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'src_format': typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'volume': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A file volume result.', 'to_dict': <function FileVolume.to_dict>, 'from_dict': <classmethod(<function FileVolume.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function FileVolume.__getitem__>, '__setitem__': <function FileVolume.__setitem__>, '__delitem__': <function FileVolume.__delitem__>, '__contains__': <function FileVolume.__contains__>, '__dict__': <attribute '__dict__' of 'FileVolume' objects>, '__weakref__': <attribute '__weakref__' of 'FileVolume' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='src_format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_import_format.FileImportFormat], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='src_format'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function FileVolume.__repr__>, '__eq__': <function FileVolume.__eq__>, '__ne__': <function FileVolume.__ne__>, '__lt__': <function FileVolume.__lt__>, '__le__': <function FileVolume.__le__>, '__gt__': <function FileVolume.__gt__>, '__ge__': <function FileVolume.__ge__>, '__hash__': None, '__init__': <function FileVolume.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id', 'volume')})

FileVolume.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, src_format=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.file_volume.FileVolume attribute)

('completed_at', 'created_at', 'error', 'id', 'output_unit', 'src_format', 'started_at', 'status', 'updated_at', 'user_id', 'volume')

additional_keys (kittycad.models.file_volume.FileVolume property)

additional_properties (kittycad.models.file_volume.FileVolume attribute)

from_dict() (kittycad.models.file_volume.FileVolume class method)

rtype

TypeVar(QF, bound= FileVolume)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.file_volume.FileVolume.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:obj:`to_dict <kittycad.models.file_volume.FileVolume.to_dict>`\ \(\)

error

id

status

user_id

volume

Gateway([auth_timeout, host, name, port, ...])

Gateway information.

:py:obj:`Gateway <kittycad.models.gateway.Gateway>`\ \(\[auth\_timeout\, host\, name\, port\, ...\]\)

Gateway(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'auth_timeout': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'port': typing.Union[kittycad.types.Unset, int], 'tls_timeout': typing.Union[kittycad.types.Unset, int]}

(Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.gateway', '__annotations__': {'auth_timeout': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'port': typing.Union[kittycad.types.Unset, int], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gateway information.', 'to_dict': <function Gateway.to_dict>, 'from_dict': <classmethod(<function Gateway.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Gateway.__getitem__>, '__setitem__': <function Gateway.__setitem__>, '__delitem__': <function Gateway.__delitem__>, '__contains__': <function Gateway.__contains__>, '__dict__': <attribute '__dict__' of 'Gateway' objects>, '__weakref__': <attribute '__weakref__' of 'Gateway' objects>, '__attrs_attrs__': (Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Gateway.__repr__>, '__eq__': <function Gateway.__eq__>, '__ne__': <function Gateway.__ne__>, '__lt__': <function Gateway.__lt__>, '__le__': <function Gateway.__le__>, '__gt__': <function Gateway.__gt__>, '__ge__': <function Gateway.__ge__>, '__hash__': None, '__init__': <function Gateway.__init__>, '__match_args__': ('auth_timeout', 'host', 'name', 'port', 'tls_timeout')})

Gateway.__init__(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

additional_properties (kittycad.models.gateway.Gateway attribute)

__init__([auth_timeout, host, name, port, ...])

Method generated by attrs for class Gateway.

rtype

TypeVar(DI, bound= Gateway)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.gateway.Gateway.__init__>`\ \(\[auth\_timeout\, host\, name\, port\, ...\]\)

:py:obj:`from_dict <kittycad.models.gateway.Gateway.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.gateway.Gateway.to_dict>`\ \(\)

host

name

port

ImageType(value[, names, module, qualname, ...])

An enumeration.

:py:obj:`ImageType <kittycad.models.image_type.ImageType>`\ \(value\[\, names\, module\, qualname\, ...\]\)

ImageType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.image_type.ImageType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.image_type', '__doc__': 'An enumeration.', '__str__': <function ImageType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['PNG', 'JPG'], '_member_map_': {'PNG': <ImageType.PNG: 'png'>, 'JPG': <ImageType.JPG: 'jpg'>}, '_value2member_map_': {'png': <ImageType.PNG: 'png'>, 'jpg': <ImageType.JPG: 'jpg'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'ImageType' objects>, '__weakref__': <attribute '__weakref__' of 'ImageType' objects>, 'PNG': <ImageType.PNG: 'png'>, 'JPG': <ImageType.JPG: 'jpg'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.image_type.ImageType method)

_generate_next_value_() (kittycad.models.image_type.ImageType method)

_unhashable_values_ (kittycad.models.image_type.ImageType attribute)

_value2member_map_ (kittycad.models.image_type.ImageType attribute)

maketrans() (kittycad.models.image_type.ImageType static method)

:py:obj:`__init__ <kittycad.models.image_type.ImageType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.image_type.ImageType.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.image_type.ImageType.casefold>`\ \(\)

:py:obj:`center <kittycad.models.image_type.ImageType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.image_type.ImageType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.image_type.ImageType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.image_type.ImageType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.image_type.ImageType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.image_type.ImageType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.image_type.ImageType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.image_type.ImageType.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.image_type.ImageType.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.image_type.ImageType.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.image_type.ImageType.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.image_type.ImageType.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.image_type.ImageType.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.image_type.ImageType.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.image_type.ImageType.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.image_type.ImageType.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.image_type.ImageType.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.image_type.ImageType.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.image_type.ImageType.isupper>`\ \(\)

:py:obj:`join <kittycad.models.image_type.ImageType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.image_type.ImageType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.image_type.ImageType.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.image_type.ImageType.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.image_type.ImageType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.image_type.ImageType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.image_type.ImageType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.image_type.ImageType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.image_type.ImageType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.image_type.ImageType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.image_type.ImageType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.image_type.ImageType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.image_type.ImageType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.image_type.ImageType.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.image_type.ImageType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.image_type.ImageType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.image_type.ImageType.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.image_type.ImageType.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.image_type.ImageType.title>`\ \(\)

:py:obj:`translate <kittycad.models.image_type.ImageType.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.image_type.ImageType.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.image_type.ImageType.zfill>`\ \(width\, \/\)

IndexInfo([mirrors, name, official, secure])

IndexInfo contains information about a registry.

:py:obj:`IndexInfo <kittycad.models.index_info.IndexInfo>`\ \(\[mirrors\, name\, official\, secure\]\)

IndexInfo(mirrors=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, official=False, secure=False)

(mirrors=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, official=False, secure=False)

__annotations__ (kittycad.models.index_info.IndexInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'mirrors': typing.Union[kittycad.types.Unset, typing.List[str]], 'name': typing.Union[kittycad.types.Unset, str], 'official': typing.Union[kittycad.types.Unset, bool], 'secure': typing.Union[kittycad.types.Unset, bool]}

__attrs_attrs__ (kittycad.models.index_info.IndexInfo attribute)

(Attribute(name='mirrors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mirrors'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='official', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='official'), Attribute(name='secure', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='secure'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.index_info', '__annotations__': {'mirrors': typing.Union[kittycad.types.Unset, typing.List[str]], 'name': typing.Union[kittycad.types.Unset, str], 'official': typing.Union[kittycad.types.Unset, bool], 'secure': typing.Union[kittycad.types.Unset, bool], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'IndexInfo contains information about a registry.', 'to_dict': <function IndexInfo.to_dict>, 'from_dict': <classmethod(<function IndexInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function IndexInfo.__getitem__>, '__setitem__': <function IndexInfo.__setitem__>, '__delitem__': <function IndexInfo.__delitem__>, '__contains__': <function IndexInfo.__contains__>, '__dict__': <attribute '__dict__' of 'IndexInfo' objects>, '__weakref__': <attribute '__weakref__' of 'IndexInfo' objects>, '__attrs_attrs__': (Attribute(name='mirrors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mirrors'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='official', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='official'), Attribute(name='secure', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='secure'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function IndexInfo.__repr__>, '__eq__': <function IndexInfo.__eq__>, '__ne__': <function IndexInfo.__ne__>, '__lt__': <function IndexInfo.__lt__>, '__le__': <function IndexInfo.__le__>, '__gt__': <function IndexInfo.__gt__>, '__ge__': <function IndexInfo.__ge__>, '__hash__': None, '__init__': <function IndexInfo.__init__>, '__match_args__': ('mirrors', 'name', 'official', 'secure')})

IndexInfo.__init__(mirrors=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, official=False, secure=False)

additional_properties (kittycad.models.index_info.IndexInfo attribute)

__init__([mirrors, name, official, secure])

Method generated by attrs for class IndexInfo.

rtype

TypeVar(OJ, bound= IndexInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.index_info.IndexInfo.__init__>`\ \(\[mirrors\, name\, official\, secure\]\)

:py:obj:`to_dict <kittycad.models.index_info.IndexInfo.to_dict>`\ \(\)

mirrors

name

official

secure

gltf([type])

Binary glTF 2.0.

obj([coords, type, units])

Wavefront OBJ format.

ply([coords, type, units])

The PLY Polygon File Format.

step([type])

ISO 10303-21 (STEP) format.

stl([coords, type, units])

*ST**ereo**L**ithography format.

:py:obj:`gltf <kittycad.models.input_format.gltf>`\ \(\[type\]\)

:py:obj:`obj <kittycad.models.input_format.obj>`\ \(\[coords\, type\, units\]\)

:py:obj:`ply <kittycad.models.input_format.ply>`\ \(\[coords\, type\, units\]\)

:py:obj:`step <kittycad.models.input_format.step>`\ \(\[type\]\)

:py:obj:`stl <kittycad.models.input_format.stl>`\ \(\[coords\, type\, units\]\)

Binary glTF 2.0. We refer to this as glTF since that is how our customers refer to it, but this can also import binary glTF (glb).

{'additional_properties': typing.Dict[str, typing.Any], 'type': <class 'str'>}

(Attribute(name='type', default='gltf', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.input_format', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Binary glTF 2.0. We refer to this as glTF since that is how our customers refer to it, but this can also import binary glTF (glb).', 'to_dict': <function gltf.to_dict>, 'from_dict': <classmethod(<function gltf.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function gltf.__getitem__>, '__setitem__': <function gltf.__setitem__>, '__delitem__': <function gltf.__delitem__>, '__contains__': <function gltf.__contains__>, '__dict__': <attribute '__dict__' of 'gltf' objects>, '__weakref__': <attribute '__weakref__' of 'gltf' objects>, '__attrs_attrs__': (Attribute(name='type', default='gltf', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function gltf.__repr__>, '__eq__': <function gltf.__eq__>, '__ne__': <function gltf.__ne__>, '__lt__': <function gltf.__lt__>, '__le__': <function gltf.__le__>, '__gt__': <function gltf.__gt__>, '__ge__': <function gltf.__ge__>, '__hash__': None, '__init__': <function gltf.__init__>, '__match_args__': ('type',)})

additional_properties (kittycad.models.input_format.gltf attribute)

obj(coords=<kittycad.types.Unset object>, type='obj', units=<kittycad.types.Unset object>)

(coords=<kittycad.types.Unset object>, type='obj', units=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'units': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength]}

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='obj', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.input_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'units': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Wavefront OBJ format.', 'to_dict': <function obj.to_dict>, 'from_dict': <classmethod(<function obj.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function obj.__getitem__>, '__setitem__': <function obj.__setitem__>, '__delitem__': <function obj.__delitem__>, '__contains__': <function obj.__contains__>, '__dict__': <attribute '__dict__' of 'obj' objects>, '__weakref__': <attribute '__weakref__' of 'obj' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='obj', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function obj.__repr__>, '__eq__': <function obj.__eq__>, '__ne__': <function obj.__ne__>, '__lt__': <function obj.__lt__>, '__le__': <function obj.__le__>, '__gt__': <function obj.__gt__>, '__ge__': <function obj.__ge__>, '__hash__': None, '__init__': <function obj.__init__>, '__match_args__': ('coords', 'type', 'units')})

obj.__init__(coords=<kittycad.types.Unset object>, type='obj', units=<kittycad.types.Unset object>)

additional_properties (kittycad.models.input_format.obj attribute)

ply(coords=<kittycad.types.Unset object>, type='ply', units=<kittycad.types.Unset object>)

(coords=<kittycad.types.Unset object>, type='ply', units=<kittycad.types.Unset object>)

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='ply', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.input_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'units': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The PLY Polygon File Format.', 'to_dict': <function ply.to_dict>, 'from_dict': <classmethod(<function ply.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ply.__getitem__>, '__setitem__': <function ply.__setitem__>, '__delitem__': <function ply.__delitem__>, '__contains__': <function ply.__contains__>, '__dict__': <attribute '__dict__' of 'ply' objects>, '__weakref__': <attribute '__weakref__' of 'ply' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='ply', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ply.__repr__>, '__eq__': <function ply.__eq__>, '__ne__': <function ply.__ne__>, '__lt__': <function ply.__lt__>, '__le__': <function ply.__le__>, '__gt__': <function ply.__gt__>, '__ge__': <function ply.__ge__>, '__hash__': None, '__init__': <function ply.__init__>, '__match_args__': ('coords', 'type', 'units')})

ply.__init__(coords=<kittycad.types.Unset object>, type='ply', units=<kittycad.types.Unset object>)

additional_properties (kittycad.models.input_format.ply attribute)

(Attribute(name='type', default='step', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.input_format', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'ISO 10303-21 (STEP) format.', 'to_dict': <function step.to_dict>, 'from_dict': <classmethod(<function step.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function step.__getitem__>, '__setitem__': <function step.__setitem__>, '__delitem__': <function step.__delitem__>, '__contains__': <function step.__contains__>, '__dict__': <attribute '__dict__' of 'step' objects>, '__weakref__': <attribute '__weakref__' of 'step' objects>, '__attrs_attrs__': (Attribute(name='type', default='step', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function step.__repr__>, '__eq__': <function step.__eq__>, '__ne__': <function step.__ne__>, '__lt__': <function step.__lt__>, '__le__': <function step.__le__>, '__gt__': <function step.__gt__>, '__ge__': <function step.__ge__>, '__hash__': None, '__init__': <function step.__init__>, '__match_args__': ('type',)})

additional_properties (kittycad.models.input_format.step attribute)

stl(coords=<kittycad.types.Unset object>, type='stl', units=<kittycad.types.Unset object>)

(coords=<kittycad.types.Unset object>, type='stl', units=<kittycad.types.Unset object>)

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='stl', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.input_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'units': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': '*ST**ereo**L**ithography format.', 'to_dict': <function stl.to_dict>, 'from_dict': <classmethod(<function stl.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function stl.__getitem__>, '__setitem__': <function stl.__setitem__>, '__delitem__': <function stl.__delitem__>, '__contains__': <function stl.__contains__>, '__dict__': <attribute '__dict__' of 'stl' objects>, '__weakref__': <attribute '__weakref__' of 'stl' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='stl', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='units', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='units'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function stl.__repr__>, '__eq__': <function stl.__eq__>, '__ne__': <function stl.__ne__>, '__lt__': <function stl.__lt__>, '__le__': <function stl.__le__>, '__gt__': <function stl.__gt__>, '__ge__': <function stl.__ge__>, '__hash__': None, '__init__': <function stl.__init__>, '__match_args__': ('coords', 'type', 'units')})

stl.__init__(coords=<kittycad.types.Unset object>, type='stl', units=<kittycad.types.Unset object>)

additional_properties (kittycad.models.input_format.stl attribute)

__init__([type])

Method generated by attrs for class gltf.

rtype

TypeVar(UF, bound= gltf)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.input_format.gltf.__init__>`\ \(\[type\]\)

:py:obj:`from_dict <kittycad.models.input_format.gltf.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.input_format.gltf.to_dict>`\ \(\)

__init__([coords, type, units])

Method generated by attrs for class obj.

rtype

TypeVar(PY, bound= obj)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.input_format.obj.__init__>`\ \(\[coords\, type\, units\]\)

:py:obj:`from_dict <kittycad.models.input_format.obj.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.input_format.obj.to_dict>`\ \(\)

coords

type

units

Method generated by attrs for class ply.

rtype

TypeVar(LK, bound= ply)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.input_format.ply.__init__>`\ \(\[coords\, type\, units\]\)

:py:obj:`from_dict <kittycad.models.input_format.ply.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.input_format.ply.to_dict>`\ \(\)

Method generated by attrs for class step.

rtype

TypeVar(YF, bound= step)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.input_format.step.__init__>`\ \(\[type\]\)

:py:obj:`from_dict <kittycad.models.input_format.step.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.input_format.step.to_dict>`\ \(\)

Method generated by attrs for class stl.

rtype

TypeVar(AR, bound= stl)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.input_format.stl.__init__>`\ \(\[coords\, type\, units\]\)

:py:obj:`from_dict <kittycad.models.input_format.stl.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.input_format.stl.to_dict>`\ \(\)

:py:obj:`Invoice <kittycad.models.invoice.Invoice>`\ \(\[amount\_due\, amount\_paid\, ...\]\)

Invoice(amount_due=<kittycad.types.Unset object>, amount_paid=<kittycad.types.Unset object>, amount_remaining=<kittycad.types.Unset object>, attempt_count=<kittycad.types.Unset object>, attempted=False, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, customer_email=<kittycad.types.Unset object>, customer_id=<kittycad.types.Unset object>, default_payment_method=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, discounts=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, lines=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, number=<kittycad.types.Unset object>, paid=False, pdf=<kittycad.types.Unset object>, receipt_number=<kittycad.types.Unset object>, statement_descriptor=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, subtotal=<kittycad.types.Unset object>, tax=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

(amount_due=<kittycad.types.Unset object>, amount_paid=<kittycad.types.Unset object>, amount_remaining=<kittycad.types.Unset object>, attempt_count=<kittycad.types.Unset object>, attempted=False, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, customer_email=<kittycad.types.Unset object>, customer_id=<kittycad.types.Unset object>, default_payment_method=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, discounts=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, lines=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, number=<kittycad.types.Unset object>, paid=False, pdf=<kittycad.types.Unset object>, receipt_number=<kittycad.types.Unset object>, statement_descriptor=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, subtotal=<kittycad.types.Unset object>, tax=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.invoice.Invoice.Discount attribute)

__attrs_attrs__ (kittycad.models.invoice.Invoice.Discount attribute)

__contains__() (kittycad.models.invoice.Invoice.Discount method)

__match_args__ (kittycad.models.invoice.Invoice.Discount attribute)

additional_keys (kittycad.models.invoice.Invoice.Discount property)

additional_properties (kittycad.models.invoice.Invoice.Discount attribute)

from_dict() (kittycad.models.invoice.Invoice.Discount class method)

Invoice.InvoiceLineItem(amount=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, invoice_item=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>)

(amount=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, invoice_item=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'amount': typing.Union[kittycad.types.Unset, float], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'description': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'invoice_item': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any]}

__attrs_attrs__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

(Attribute(name='amount', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='description', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='invoice_item', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='invoice_item'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__delitem__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__dict__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

mappingproxy({'__module__': 'kittycad.models.invoice_line_item', '__annotations__': {'amount': typing.Union[kittycad.types.Unset, float], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'description': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'invoice_item': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An invoice line item.', 'to_dict': <function InvoiceLineItem.to_dict>, 'from_dict': <classmethod(<function InvoiceLineItem.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function InvoiceLineItem.__getitem__>, '__setitem__': <function InvoiceLineItem.__setitem__>, '__delitem__': <function InvoiceLineItem.__delitem__>, '__contains__': <function InvoiceLineItem.__contains__>, '__dict__': <attribute '__dict__' of 'InvoiceLineItem' objects>, '__weakref__': <attribute '__weakref__' of 'InvoiceLineItem' objects>, '__attrs_attrs__': (Attribute(name='amount', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='description', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='invoice_item', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='invoice_item'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function InvoiceLineItem.__repr__>, '__eq__': <function InvoiceLineItem.__eq__>, '__ne__': <function InvoiceLineItem.__ne__>, '__lt__': <function InvoiceLineItem.__lt__>, '__le__': <function InvoiceLineItem.__le__>, '__gt__': <function InvoiceLineItem.__gt__>, '__ge__': <function InvoiceLineItem.__ge__>, '__hash__': None, '__init__': <function InvoiceLineItem.__init__>, '__match_args__': ('amount', 'currency', 'description', 'id', 'invoice_item', 'metadata')})

__eq__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__ge__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__getitem__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__gt__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__hash__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

__init__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

Invoice.InvoiceLineItem.__init__(amount=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, invoice_item=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>)

__le__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__lt__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__match_args__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

('amount', 'currency', 'description', 'id', 'invoice_item', 'metadata')

__module__ (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

__ne__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__repr__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

__setitem__() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

additional_keys (kittycad.models.invoice.Invoice.InvoiceLineItem property)

amount (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

currency (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

description (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

from_dict() (kittycad.models.invoice.Invoice.InvoiceLineItem class method)

invoice_item (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

metadata (kittycad.models.invoice.Invoice.InvoiceLineItem attribute)

to_dict() (kittycad.models.invoice.Invoice.InvoiceLineItem method)

{'additional_properties': typing.Dict[str, typing.Any], 'amount_due': typing.Union[kittycad.types.Unset, float], 'amount_paid': typing.Union[kittycad.types.Unset, float], 'amount_remaining': typing.Union[kittycad.types.Unset, float], 'attempt_count': typing.Union[kittycad.types.Unset, int], 'attempted': typing.Union[kittycad.types.Unset, bool], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'customer_email': typing.Union[kittycad.types.Unset, str], 'customer_id': typing.Union[kittycad.types.Unset, str], 'default_payment_method': typing.Union[kittycad.types.Unset, str], 'description': typing.Union[kittycad.types.Unset, str], 'discounts': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.discount.Discount]], 'id': typing.Union[kittycad.types.Unset, str], 'lines': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.invoice_line_item.InvoiceLineItem]], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'number': typing.Union[kittycad.types.Unset, str], 'paid': typing.Union[kittycad.types.Unset, bool], 'pdf': typing.Union[kittycad.types.Unset, str], 'receipt_number': typing.Union[kittycad.types.Unset, str], 'statement_descriptor': typing.Union[kittycad.types.Unset, str], 'status': typing.Union[kittycad.types.Unset, kittycad.models.invoice_status.InvoiceStatus], 'subtotal': typing.Union[kittycad.types.Unset, float], 'tax': typing.Union[kittycad.types.Unset, float], 'total': typing.Union[kittycad.types.Unset, float], 'url': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='amount_due', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_due'), Attribute(name='amount_paid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_paid'), Attribute(name='amount_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_remaining'), Attribute(name='attempt_count', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='attempt_count'), Attribute(name='attempted', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='attempted'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='customer_email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='customer_email'), Attribute(name='customer_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='customer_id'), Attribute(name='default_payment_method', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_payment_method'), Attribute(name='description', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description'), Attribute(name='discounts', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.discount.Discount]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discounts'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='lines', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.invoice_line_item.InvoiceLineItem]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='lines'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='number', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='number'), Attribute(name='paid', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='paid'), Attribute(name='pdf', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pdf'), Attribute(name='receipt_number', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='receipt_number'), Attribute(name='statement_descriptor', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='statement_descriptor'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.invoice_status.InvoiceStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='subtotal', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='subtotal'), Attribute(name='tax', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tax'), Attribute(name='total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.invoice', '__annotations__': {'amount_due': typing.Union[kittycad.types.Unset, float], 'amount_paid': typing.Union[kittycad.types.Unset, float], 'amount_remaining': typing.Union[kittycad.types.Unset, float], 'attempt_count': typing.Union[kittycad.types.Unset, int], 'attempted': typing.Union[kittycad.types.Unset, bool], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'currency': typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], 'customer_email': typing.Union[kittycad.types.Unset, str], 'customer_id': typing.Union[kittycad.types.Unset, str], 'default_payment_method': typing.Union[kittycad.types.Unset, str], 'description': typing.Union[kittycad.types.Unset, str], 'discounts': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.discount.Discount]], 'id': typing.Union[kittycad.types.Unset, str], 'lines': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.invoice_line_item.InvoiceLineItem]], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'number': typing.Union[kittycad.types.Unset, str], 'paid': typing.Union[kittycad.types.Unset, bool], 'pdf': typing.Union[kittycad.types.Unset, str], 'receipt_number': typing.Union[kittycad.types.Unset, str], 'statement_descriptor': typing.Union[kittycad.types.Unset, str], 'status': typing.Union[kittycad.types.Unset, kittycad.models.invoice_status.InvoiceStatus], 'subtotal': typing.Union[kittycad.types.Unset, float], 'tax': typing.Union[kittycad.types.Unset, float], 'total': typing.Union[kittycad.types.Unset, float], 'url': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An invoice.', 'Discount': <class 'kittycad.models.discount.Discount'>, 'InvoiceLineItem': <class 'kittycad.models.invoice_line_item.InvoiceLineItem'>, 'to_dict': <function Invoice.to_dict>, 'from_dict': <classmethod(<function Invoice.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Invoice.__getitem__>, '__setitem__': <function Invoice.__setitem__>, '__delitem__': <function Invoice.__delitem__>, '__contains__': <function Invoice.__contains__>, '__dict__': <attribute '__dict__' of 'Invoice' objects>, '__weakref__': <attribute '__weakref__' of 'Invoice' objects>, '__attrs_attrs__': (Attribute(name='amount_due', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_due'), Attribute(name='amount_paid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_paid'), Attribute(name='amount_remaining', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='amount_remaining'), Attribute(name='attempt_count', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='attempt_count'), Attribute(name='attempted', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='attempted'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='currency', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.currency.Currency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='currency'), Attribute(name='customer_email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='customer_email'), Attribute(name='customer_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='customer_id'), Attribute(name='default_payment_method', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='default_payment_method'), Attribute(name='description', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='description'), Attribute(name='discounts', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.discount.Discount]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discounts'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='lines', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.invoice_line_item.InvoiceLineItem]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='lines'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='number', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='number'), Attribute(name='paid', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='paid'), Attribute(name='pdf', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pdf'), Attribute(name='receipt_number', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='receipt_number'), Attribute(name='statement_descriptor', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='statement_descriptor'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.invoice_status.InvoiceStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='subtotal', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='subtotal'), Attribute(name='tax', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tax'), Attribute(name='total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Invoice.__repr__>, '__eq__': <function Invoice.__eq__>, '__ne__': <function Invoice.__ne__>, '__lt__': <function Invoice.__lt__>, '__le__': <function Invoice.__le__>, '__gt__': <function Invoice.__gt__>, '__ge__': <function Invoice.__ge__>, '__hash__': None, '__init__': <function Invoice.__init__>, '__match_args__': ('amount_due', 'amount_paid', 'amount_remaining', 'attempt_count', 'attempted', 'created_at', 'currency', 'customer_email', 'customer_id', 'default_payment_method', 'description', 'discounts', 'id', 'lines', 'metadata', 'number', 'paid', 'pdf', 'receipt_number', 'statement_descriptor', 'status', 'subtotal', 'tax', 'total', 'url')})

Invoice.__init__(amount_due=<kittycad.types.Unset object>, amount_paid=<kittycad.types.Unset object>, amount_remaining=<kittycad.types.Unset object>, attempt_count=<kittycad.types.Unset object>, attempted=False, created_at=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, customer_email=<kittycad.types.Unset object>, customer_id=<kittycad.types.Unset object>, default_payment_method=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, discounts=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, lines=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, number=<kittycad.types.Unset object>, paid=False, pdf=<kittycad.types.Unset object>, receipt_number=<kittycad.types.Unset object>, statement_descriptor=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, subtotal=<kittycad.types.Unset object>, tax=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

('amount_due', 'amount_paid', 'amount_remaining', 'attempt_count', 'attempted', 'created_at', 'currency', 'customer_email', 'customer_id', 'default_payment_method', 'description', 'discounts', 'id', 'lines', 'metadata', 'number', 'paid', 'pdf', 'receipt_number', 'statement_descriptor', 'status', 'subtotal', 'tax', 'total', 'url')

additional_properties (kittycad.models.invoice.Invoice attribute)

default_payment_method (kittycad.models.invoice.Invoice attribute)

statement_descriptor (kittycad.models.invoice.Invoice attribute)

__init__([amount_due, amount_paid, ...])

Method generated by attrs for class Invoice.

rtype

TypeVar(WB, bound= Invoice)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.invoice.Invoice.__init__>`\ \(\[amount\_due\, amount\_paid\, ...\]\)

:py:obj:`from_dict <kittycad.models.invoice.Invoice.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.invoice.Invoice.to_dict>`\ \(\)

amount_due

amount_paid

amount_remaining

attempt_count

attempted

currency

customer_email

customer_id

default_payment_method

description

discounts

id

lines

metadata

number

paid

pdf

receipt_number

statement_descriptor

status

subtotal

tax

total

url

InvoiceLineItem([amount, currency, ...])

An invoice line item.

:py:obj:`InvoiceLineItem <kittycad.models.invoice_line_item.InvoiceLineItem>`\ \(\[amount\, currency\, ...\]\)

InvoiceLineItem(amount=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, invoice_item=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__attrs_attrs__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__contains__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__delitem__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__dict__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__eq__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__ge__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__getitem__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__gt__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__hash__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__init__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

InvoiceLineItem.__init__(amount=<kittycad.types.Unset object>, currency=<kittycad.types.Unset object>, description=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, invoice_item=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>)

__le__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__lt__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__match_args__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__module__ (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

__ne__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__repr__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__setitem__() (kittycad.models.invoice_line_item.InvoiceLineItem method)

additional_keys (kittycad.models.invoice_line_item.InvoiceLineItem property)

amount (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

currency (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

description (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

from_dict() (kittycad.models.invoice_line_item.InvoiceLineItem class method)

id (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

invoice_item (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

metadata (kittycad.models.invoice_line_item.InvoiceLineItem attribute)

to_dict() (kittycad.models.invoice_line_item.InvoiceLineItem method)

__init__([amount, currency, description, ...])

Method generated by attrs for class InvoiceLineItem.

rtype

TypeVar(KK, bound= InvoiceLineItem)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.invoice_line_item.InvoiceLineItem.__init__>`\ \(\[amount\, currency\, description\, ...\]\)

amount

currency

id

invoice_item

metadata

InvoiceStatus(value[, names, module, ...])

An enum representing the possible values of an Invoice's status field.

:py:obj:`InvoiceStatus <kittycad.models.invoice_status.InvoiceStatus>`\ \(value\[\, names\, module\, ...\]\)

An enum representing the possible values of an `Invoice`'s `status` field.

InvoiceStatus(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

DELETED (kittycad.models.invoice_status.InvoiceStatus attribute)

docstring of kittycad.models.invoice_status.InvoiceStatus.DELETED

UNCOLLECTIBLE (kittycad.models.invoice_status.InvoiceStatus attribute)

docstring of kittycad.models.invoice_status.InvoiceStatus.UNCOLLECTIBLE

__annotations__ (kittycad.models.invoice_status.InvoiceStatus attribute)

__contains__() (kittycad.models.invoice_status.InvoiceStatus method)

__dict__ (kittycad.models.invoice_status.InvoiceStatus attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.invoice_status', '__doc__': "An enum representing the possible values of an `Invoice`'s `status` field.", '__str__': <function InvoiceStatus.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['DELETED', 'DRAFT', 'OPEN', 'PAID', 'UNCOLLECTIBLE', 'VOID'], '_member_map_': {'DELETED': <InvoiceStatus.DELETED: 'deleted'>, 'DRAFT': <InvoiceStatus.DRAFT: 'draft'>, 'OPEN': <InvoiceStatus.OPEN: 'open'>, 'PAID': <InvoiceStatus.PAID: 'paid'>, 'UNCOLLECTIBLE': <InvoiceStatus.UNCOLLECTIBLE: 'uncollectible'>, 'VOID': <InvoiceStatus.VOID: 'void'>}, '_value2member_map_': {'deleted': <InvoiceStatus.DELETED: 'deleted'>, 'draft': <InvoiceStatus.DRAFT: 'draft'>, 'open': <InvoiceStatus.OPEN: 'open'>, 'paid': <InvoiceStatus.PAID: 'paid'>, 'uncollectible': <InvoiceStatus.UNCOLLECTIBLE: 'uncollectible'>, 'void': <InvoiceStatus.VOID: 'void'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'InvoiceStatus' objects>, '__weakref__': <attribute '__weakref__' of 'InvoiceStatus' objects>, 'DELETED': <InvoiceStatus.DELETED: 'deleted'>, 'DRAFT': <InvoiceStatus.DRAFT: 'draft'>, 'OPEN': <InvoiceStatus.OPEN: 'open'>, 'PAID': <InvoiceStatus.PAID: 'paid'>, 'UNCOLLECTIBLE': <InvoiceStatus.UNCOLLECTIBLE: 'uncollectible'>, 'VOID': <InvoiceStatus.VOID: 'void'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__format__() (kittycad.models.invoice_status.InvoiceStatus method)

__getattribute__() (kittycad.models.invoice_status.InvoiceStatus method)

__getitem__() (kittycad.models.invoice_status.InvoiceStatus method)

__getnewargs__() (kittycad.models.invoice_status.InvoiceStatus method)

__hash__() (kittycad.models.invoice_status.InvoiceStatus method)

__init__() (kittycad.models.invoice_status.InvoiceStatus method)

__iter__() (kittycad.models.invoice_status.InvoiceStatus method)

__module__ (kittycad.models.invoice_status.InvoiceStatus attribute)

__reduce_ex__() (kittycad.models.invoice_status.InvoiceStatus method)

__repr__() (kittycad.models.invoice_status.InvoiceStatus method)

__rmod__() (kittycad.models.invoice_status.InvoiceStatus method)

__rmul__() (kittycad.models.invoice_status.InvoiceStatus method)

__sizeof__() (kittycad.models.invoice_status.InvoiceStatus method)

_generate_next_value_() (kittycad.models.invoice_status.InvoiceStatus method)

_member_map_ (kittycad.models.invoice_status.InvoiceStatus attribute)

{'DELETED': InvoiceStatus.DELETED, 'DRAFT': InvoiceStatus.DRAFT, 'OPEN': InvoiceStatus.OPEN, 'PAID': InvoiceStatus.PAID, 'UNCOLLECTIBLE': InvoiceStatus.UNCOLLECTIBLE, 'VOID': InvoiceStatus.VOID}

_member_names_ (kittycad.models.invoice_status.InvoiceStatus attribute)

_member_type_ (kittycad.models.invoice_status.InvoiceStatus attribute)

_new_member_() (kittycad.models.invoice_status.InvoiceStatus method)

_unhashable_values_ (kittycad.models.invoice_status.InvoiceStatus attribute)

_use_args_ (kittycad.models.invoice_status.InvoiceStatus attribute)

_value2member_map_ (kittycad.models.invoice_status.InvoiceStatus attribute)

{'deleted': InvoiceStatus.DELETED, 'draft': InvoiceStatus.DRAFT, 'open': InvoiceStatus.OPEN, 'paid': InvoiceStatus.PAID, 'uncollectible': InvoiceStatus.UNCOLLECTIBLE, 'void': InvoiceStatus.VOID}

_value_repr_() (kittycad.models.invoice_status.InvoiceStatus method)

capitalize() (kittycad.models.invoice_status.InvoiceStatus method)

casefold() (kittycad.models.invoice_status.InvoiceStatus method)

endswith() (kittycad.models.invoice_status.InvoiceStatus method)

expandtabs() (kittycad.models.invoice_status.InvoiceStatus method)

format_map() (kittycad.models.invoice_status.InvoiceStatus method)

isdecimal() (kittycad.models.invoice_status.InvoiceStatus method)

isidentifier() (kittycad.models.invoice_status.InvoiceStatus method)

isnumeric() (kittycad.models.invoice_status.InvoiceStatus method)

isprintable() (kittycad.models.invoice_status.InvoiceStatus method)

maketrans() (kittycad.models.invoice_status.InvoiceStatus static method)

partition() (kittycad.models.invoice_status.InvoiceStatus method)

removeprefix() (kittycad.models.invoice_status.InvoiceStatus method)

removesuffix() (kittycad.models.invoice_status.InvoiceStatus method)

rpartition() (kittycad.models.invoice_status.InvoiceStatus method)

splitlines() (kittycad.models.invoice_status.InvoiceStatus method)

startswith() (kittycad.models.invoice_status.InvoiceStatus method)

swapcase() (kittycad.models.invoice_status.InvoiceStatus method)

translate() (kittycad.models.invoice_status.InvoiceStatus method)

:py:obj:`__init__ <kittycad.models.invoice_status.InvoiceStatus.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`casefold <kittycad.models.invoice_status.InvoiceStatus.casefold>`\ \(\)

:py:obj:`center <kittycad.models.invoice_status.InvoiceStatus.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.invoice_status.InvoiceStatus.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.invoice_status.InvoiceStatus.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.invoice_status.InvoiceStatus.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.invoice_status.InvoiceStatus.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.invoice_status.InvoiceStatus.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.invoice_status.InvoiceStatus.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.invoice_status.InvoiceStatus.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.invoice_status.InvoiceStatus.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.invoice_status.InvoiceStatus.isascii>`\ \(\)

:py:obj:`isdigit <kittycad.models.invoice_status.InvoiceStatus.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.invoice_status.InvoiceStatus.islower>`\ \(\)

:py:obj:`isspace <kittycad.models.invoice_status.InvoiceStatus.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.invoice_status.InvoiceStatus.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.invoice_status.InvoiceStatus.isupper>`\ \(\)

:py:obj:`join <kittycad.models.invoice_status.InvoiceStatus.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.invoice_status.InvoiceStatus.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.invoice_status.InvoiceStatus.lower>`\ \(\)

:py:obj:`partition <kittycad.models.invoice_status.InvoiceStatus.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.invoice_status.InvoiceStatus.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.invoice_status.InvoiceStatus.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.invoice_status.InvoiceStatus.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.invoice_status.InvoiceStatus.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.invoice_status.InvoiceStatus.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.invoice_status.InvoiceStatus.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.invoice_status.InvoiceStatus.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.invoice_status.InvoiceStatus.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.invoice_status.InvoiceStatus.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.invoice_status.InvoiceStatus.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`swapcase <kittycad.models.invoice_status.InvoiceStatus.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.invoice_status.InvoiceStatus.title>`\ \(\)

:py:obj:`translate <kittycad.models.invoice_status.InvoiceStatus.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.invoice_status.InvoiceStatus.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.invoice_status.InvoiceStatus.zfill>`\ \(width\, \/\)

DELETED

# Draft.

DRAFT

# Open.

OPEN

# Paid.

PAID

# Uncollectible.

UNCOLLECTIBLE

# Void.

VOID

:py:obj:`Jetstream <kittycad.models.jetstream.Jetstream>`\ \(\[config\, meta\, stats\]\)

Jetstream(config=<kittycad.types.Unset object>, meta=<kittycad.types.Unset object>, stats=<kittycad.types.Unset object>)

(config=<kittycad.types.Unset object>, meta=<kittycad.types.Unset object>, stats=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'config': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_config.JetstreamConfig], 'meta': typing.Union[kittycad.types.Unset, kittycad.models.meta_cluster_info.MetaClusterInfo], 'stats': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_stats.JetstreamStats]}

(Attribute(name='config', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_config.JetstreamConfig], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='config'), Attribute(name='meta', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.meta_cluster_info.MetaClusterInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='meta'), Attribute(name='stats', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_stats.JetstreamStats], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stats'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.jetstream', '__annotations__': {'config': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_config.JetstreamConfig], 'meta': typing.Union[kittycad.types.Unset, kittycad.models.meta_cluster_info.MetaClusterInfo], 'stats': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_stats.JetstreamStats], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Jetstream information.', 'to_dict': <function Jetstream.to_dict>, 'from_dict': <classmethod(<function Jetstream.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Jetstream.__getitem__>, '__setitem__': <function Jetstream.__setitem__>, '__delitem__': <function Jetstream.__delitem__>, '__contains__': <function Jetstream.__contains__>, '__dict__': <attribute '__dict__' of 'Jetstream' objects>, '__weakref__': <attribute '__weakref__' of 'Jetstream' objects>, '__attrs_attrs__': (Attribute(name='config', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_config.JetstreamConfig], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='config'), Attribute(name='meta', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.meta_cluster_info.MetaClusterInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='meta'), Attribute(name='stats', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_stats.JetstreamStats], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='stats'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Jetstream.__repr__>, '__eq__': <function Jetstream.__eq__>, '__ne__': <function Jetstream.__ne__>, '__lt__': <function Jetstream.__lt__>, '__le__': <function Jetstream.__le__>, '__gt__': <function Jetstream.__gt__>, '__ge__': <function Jetstream.__ge__>, '__hash__': None, '__init__': <function Jetstream.__init__>, '__match_args__': ('config', 'meta', 'stats')})

Jetstream.__init__(config=<kittycad.types.Unset object>, meta=<kittycad.types.Unset object>, stats=<kittycad.types.Unset object>)

additional_properties (kittycad.models.jetstream.Jetstream attribute)

__init__([config, meta, stats])

Method generated by attrs for class Jetstream.

rtype

TypeVar(HC, bound= Jetstream)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.jetstream.Jetstream.__init__>`\ \(\[config\, meta\, stats\]\)

:py:obj:`to_dict <kittycad.models.jetstream.Jetstream.to_dict>`\ \(\)

config

meta

stats

JetstreamApiStats([errors, inflight, total])

Jetstream API statistics.

:py:obj:`JetstreamApiStats <kittycad.models.jetstream_api_stats.JetstreamApiStats>`\ \(\[errors\, inflight\, total\]\)

JetstreamApiStats (class in kittycad.models.jetstream_api_stats)

JetstreamApiStats(errors=<kittycad.types.Unset object>, inflight=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>)

(errors=<kittycad.types.Unset object>, inflight=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'errors': typing.Union[kittycad.types.Unset, int], 'inflight': typing.Union[kittycad.types.Unset, int], 'total': typing.Union[kittycad.types.Unset, int]}

(Attribute(name='errors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='errors'), Attribute(name='inflight', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='inflight'), Attribute(name='total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__delitem__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__dict__ (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

mappingproxy({'__module__': 'kittycad.models.jetstream_api_stats', '__annotations__': {'errors': typing.Union[kittycad.types.Unset, int], 'inflight': typing.Union[kittycad.types.Unset, int], 'total': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Jetstream API statistics.', 'to_dict': <function JetstreamApiStats.to_dict>, 'from_dict': <classmethod(<function JetstreamApiStats.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function JetstreamApiStats.__getitem__>, '__setitem__': <function JetstreamApiStats.__setitem__>, '__delitem__': <function JetstreamApiStats.__delitem__>, '__contains__': <function JetstreamApiStats.__contains__>, '__dict__': <attribute '__dict__' of 'JetstreamApiStats' objects>, '__weakref__': <attribute '__weakref__' of 'JetstreamApiStats' objects>, '__attrs_attrs__': (Attribute(name='errors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='errors'), Attribute(name='inflight', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='inflight'), Attribute(name='total', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='total'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function JetstreamApiStats.__repr__>, '__eq__': <function JetstreamApiStats.__eq__>, '__ne__': <function JetstreamApiStats.__ne__>, '__lt__': <function JetstreamApiStats.__lt__>, '__le__': <function JetstreamApiStats.__le__>, '__gt__': <function JetstreamApiStats.__gt__>, '__ge__': <function JetstreamApiStats.__ge__>, '__hash__': None, '__init__': <function JetstreamApiStats.__init__>, '__match_args__': ('errors', 'inflight', 'total')})

__eq__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__ge__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__getitem__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__gt__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__hash__ (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

__init__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

JetstreamApiStats.__init__(errors=<kittycad.types.Unset object>, inflight=<kittycad.types.Unset object>, total=<kittycad.types.Unset object>)

__le__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__lt__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__match_args__ (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

__module__ (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

__ne__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__repr__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

__setitem__() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

additional_keys (kittycad.models.jetstream_api_stats.JetstreamApiStats property)

errors (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

from_dict() (kittycad.models.jetstream_api_stats.JetstreamApiStats class method)

inflight (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

to_dict() (kittycad.models.jetstream_api_stats.JetstreamApiStats method)

total (kittycad.models.jetstream_api_stats.JetstreamApiStats attribute)

__init__([errors, inflight, total])

Method generated by attrs for class JetstreamApiStats.

rtype

TypeVar(FM, bound= JetstreamApiStats)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.jetstream_api_stats.JetstreamApiStats.__init__>`\ \(\[errors\, inflight\, total\]\)

errors

inflight

total

JetstreamConfig([domain, max_memory, ...])

Jetstream configuration.

:py:obj:`JetstreamConfig <kittycad.models.jetstream_config.JetstreamConfig>`\ \(\[domain\, max\_memory\, ...\]\)

JetstreamConfig(domain=<kittycad.types.Unset object>, max_memory=<kittycad.types.Unset object>, max_storage=<kittycad.types.Unset object>, store_dir=<kittycad.types.Unset object>)

(domain=<kittycad.types.Unset object>, max_memory=<kittycad.types.Unset object>, max_storage=<kittycad.types.Unset object>, store_dir=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'domain': typing.Union[kittycad.types.Unset, str], 'max_memory': typing.Union[kittycad.types.Unset, int], 'max_storage': typing.Union[kittycad.types.Unset, int], 'store_dir': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

(Attribute(name='domain', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='domain'), Attribute(name='max_memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_memory'), Attribute(name='max_storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_storage'), Attribute(name='store_dir', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='store_dir'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.jetstream_config.JetstreamConfig method)

__delitem__() (kittycad.models.jetstream_config.JetstreamConfig method)

__dict__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

mappingproxy({'__module__': 'kittycad.models.jetstream_config', '__annotations__': {'domain': typing.Union[kittycad.types.Unset, str], 'max_memory': typing.Union[kittycad.types.Unset, int], 'max_storage': typing.Union[kittycad.types.Unset, int], 'store_dir': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Jetstream configuration.', 'to_dict': <function JetstreamConfig.to_dict>, 'from_dict': <classmethod(<function JetstreamConfig.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function JetstreamConfig.__getitem__>, '__setitem__': <function JetstreamConfig.__setitem__>, '__delitem__': <function JetstreamConfig.__delitem__>, '__contains__': <function JetstreamConfig.__contains__>, '__dict__': <attribute '__dict__' of 'JetstreamConfig' objects>, '__weakref__': <attribute '__weakref__' of 'JetstreamConfig' objects>, '__attrs_attrs__': (Attribute(name='domain', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='domain'), Attribute(name='max_memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_memory'), Attribute(name='max_storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='max_storage'), Attribute(name='store_dir', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='store_dir'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function JetstreamConfig.__repr__>, '__eq__': <function JetstreamConfig.__eq__>, '__ne__': <function JetstreamConfig.__ne__>, '__lt__': <function JetstreamConfig.__lt__>, '__le__': <function JetstreamConfig.__le__>, '__gt__': <function JetstreamConfig.__gt__>, '__ge__': <function JetstreamConfig.__ge__>, '__hash__': None, '__init__': <function JetstreamConfig.__init__>, '__match_args__': ('domain', 'max_memory', 'max_storage', 'store_dir')})

__eq__() (kittycad.models.jetstream_config.JetstreamConfig method)

__ge__() (kittycad.models.jetstream_config.JetstreamConfig method)

__getitem__() (kittycad.models.jetstream_config.JetstreamConfig method)

__gt__() (kittycad.models.jetstream_config.JetstreamConfig method)

__hash__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

__init__() (kittycad.models.jetstream_config.JetstreamConfig method)

JetstreamConfig.__init__(domain=<kittycad.types.Unset object>, max_memory=<kittycad.types.Unset object>, max_storage=<kittycad.types.Unset object>, store_dir=<kittycad.types.Unset object>)

__le__() (kittycad.models.jetstream_config.JetstreamConfig method)

__lt__() (kittycad.models.jetstream_config.JetstreamConfig method)

__match_args__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

__module__ (kittycad.models.jetstream_config.JetstreamConfig attribute)

__ne__() (kittycad.models.jetstream_config.JetstreamConfig method)

__repr__() (kittycad.models.jetstream_config.JetstreamConfig method)

__setitem__() (kittycad.models.jetstream_config.JetstreamConfig method)

additional_keys (kittycad.models.jetstream_config.JetstreamConfig property)

domain (kittycad.models.jetstream_config.JetstreamConfig attribute)

from_dict() (kittycad.models.jetstream_config.JetstreamConfig class method)

max_memory (kittycad.models.jetstream_config.JetstreamConfig attribute)

max_storage (kittycad.models.jetstream_config.JetstreamConfig attribute)

store_dir (kittycad.models.jetstream_config.JetstreamConfig attribute)

to_dict() (kittycad.models.jetstream_config.JetstreamConfig method)

__init__([domain, max_memory, max_storage, ...])

Method generated by attrs for class JetstreamConfig.

rtype

TypeVar(PV, bound= JetstreamConfig)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.jetstream_config.JetstreamConfig.__init__>`\ \(\[domain\, max\_memory\, max\_storage\, ...\]\)

domain

max_memory

max_storage

store_dir

JetstreamStats([accounts, api, ha_assets, ...])

Jetstream statistics.

:py:obj:`JetstreamStats <kittycad.models.jetstream_stats.JetstreamStats>`\ \(\[accounts\, api\, ha\_assets\, ...\]\)

JetstreamStats(accounts=<kittycad.types.Unset object>, api=<kittycad.types.Unset object>, ha_assets=<kittycad.types.Unset object>, memory=<kittycad.types.Unset object>, reserved_memory=<kittycad.types.Unset object>, reserved_store=<kittycad.types.Unset object>, store=<kittycad.types.Unset object>)

(accounts=<kittycad.types.Unset object>, api=<kittycad.types.Unset object>, ha_assets=<kittycad.types.Unset object>, memory=<kittycad.types.Unset object>, reserved_memory=<kittycad.types.Unset object>, reserved_store=<kittycad.types.Unset object>, store=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

{'accounts': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any], 'api': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_api_stats.JetstreamApiStats], 'ha_assets': typing.Union[kittycad.types.Unset, int], 'memory': typing.Union[kittycad.types.Unset, int], 'reserved_memory': typing.Union[kittycad.types.Unset, int], 'reserved_store': typing.Union[kittycad.types.Unset, int], 'store': typing.Union[kittycad.types.Unset, int]}

__attrs_attrs__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

(Attribute(name='accounts', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='accounts'), Attribute(name='api', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_api_stats.JetstreamApiStats], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='api'), Attribute(name='ha_assets', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ha_assets'), Attribute(name='memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='memory'), Attribute(name='reserved_memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='reserved_memory'), Attribute(name='reserved_store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='reserved_store'), Attribute(name='store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='store'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.jetstream_stats.JetstreamStats method)

__delitem__() (kittycad.models.jetstream_stats.JetstreamStats method)

__dict__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

mappingproxy({'__module__': 'kittycad.models.jetstream_stats', '__annotations__': {'accounts': typing.Union[kittycad.types.Unset, int], 'api': typing.Union[kittycad.types.Unset, kittycad.models.jetstream_api_stats.JetstreamApiStats], 'ha_assets': typing.Union[kittycad.types.Unset, int], 'memory': typing.Union[kittycad.types.Unset, int], 'reserved_memory': typing.Union[kittycad.types.Unset, int], 'reserved_store': typing.Union[kittycad.types.Unset, int], 'store': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Jetstream statistics.', 'to_dict': <function JetstreamStats.to_dict>, 'from_dict': <classmethod(<function JetstreamStats.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function JetstreamStats.__getitem__>, '__setitem__': <function JetstreamStats.__setitem__>, '__delitem__': <function JetstreamStats.__delitem__>, '__contains__': <function JetstreamStats.__contains__>, '__dict__': <attribute '__dict__' of 'JetstreamStats' objects>, '__weakref__': <attribute '__weakref__' of 'JetstreamStats' objects>, '__attrs_attrs__': (Attribute(name='accounts', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='accounts'), Attribute(name='api', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.jetstream_api_stats.JetstreamApiStats], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='api'), Attribute(name='ha_assets', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ha_assets'), Attribute(name='memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='memory'), Attribute(name='reserved_memory', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='reserved_memory'), Attribute(name='reserved_store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='reserved_store'), Attribute(name='store', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='store'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function JetstreamStats.__repr__>, '__eq__': <function JetstreamStats.__eq__>, '__ne__': <function JetstreamStats.__ne__>, '__lt__': <function JetstreamStats.__lt__>, '__le__': <function JetstreamStats.__le__>, '__gt__': <function JetstreamStats.__gt__>, '__ge__': <function JetstreamStats.__ge__>, '__hash__': None, '__init__': <function JetstreamStats.__init__>, '__match_args__': ('accounts', 'api', 'ha_assets', 'memory', 'reserved_memory', 'reserved_store', 'store')})

__eq__() (kittycad.models.jetstream_stats.JetstreamStats method)

__ge__() (kittycad.models.jetstream_stats.JetstreamStats method)

__getitem__() (kittycad.models.jetstream_stats.JetstreamStats method)

__gt__() (kittycad.models.jetstream_stats.JetstreamStats method)

__hash__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

__init__() (kittycad.models.jetstream_stats.JetstreamStats method)

JetstreamStats.__init__(accounts=<kittycad.types.Unset object>, api=<kittycad.types.Unset object>, ha_assets=<kittycad.types.Unset object>, memory=<kittycad.types.Unset object>, reserved_memory=<kittycad.types.Unset object>, reserved_store=<kittycad.types.Unset object>, store=<kittycad.types.Unset object>)

__le__() (kittycad.models.jetstream_stats.JetstreamStats method)

__lt__() (kittycad.models.jetstream_stats.JetstreamStats method)

__match_args__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

('accounts', 'api', 'ha_assets', 'memory', 'reserved_memory', 'reserved_store', 'store')

__module__ (kittycad.models.jetstream_stats.JetstreamStats attribute)

__ne__() (kittycad.models.jetstream_stats.JetstreamStats method)

__repr__() (kittycad.models.jetstream_stats.JetstreamStats method)

__setitem__() (kittycad.models.jetstream_stats.JetstreamStats method)

accounts (kittycad.models.jetstream_stats.JetstreamStats attribute)

additional_keys (kittycad.models.jetstream_stats.JetstreamStats property)

additional_properties (kittycad.models.jetstream_stats.JetstreamStats attribute)

from_dict() (kittycad.models.jetstream_stats.JetstreamStats class method)

ha_assets (kittycad.models.jetstream_stats.JetstreamStats attribute)

memory (kittycad.models.jetstream_stats.JetstreamStats attribute)

reserved_memory (kittycad.models.jetstream_stats.JetstreamStats attribute)

reserved_store (kittycad.models.jetstream_stats.JetstreamStats attribute)

store (kittycad.models.jetstream_stats.JetstreamStats attribute)

to_dict() (kittycad.models.jetstream_stats.JetstreamStats method)

__init__([accounts, api, ha_assets, memory, ...])

Method generated by attrs for class JetstreamStats.

rtype

TypeVar(QI, bound= JetstreamStats)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.jetstream_stats.JetstreamStats.__init__>`\ \(\[accounts\, api\, ha\_assets\, memory\, ...\]\)

:py:obj:`to_dict <kittycad.models.jetstream_stats.JetstreamStats.to_dict>`\ \(\)

accounts

api

ha_assets

memory

reserved_memory

reserved_store

store

LeafNode([auth_timeout, host, port, tls_timeout])

Leaf node information.

:py:obj:`LeafNode <kittycad.models.leaf_node.LeafNode>`\ \(\[auth\_timeout\, host\, port\, tls\_timeout\]\)

LeafNode(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'auth_timeout': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'port': typing.Union[kittycad.types.Unset, int], 'tls_timeout': typing.Union[kittycad.types.Unset, int]}

(Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.leaf_node', '__annotations__': {'auth_timeout': typing.Union[kittycad.types.Unset, int], 'host': typing.Union[kittycad.types.Unset, str], 'port': typing.Union[kittycad.types.Unset, int], 'tls_timeout': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Leaf node information.', 'to_dict': <function LeafNode.to_dict>, 'from_dict': <classmethod(<function LeafNode.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function LeafNode.__getitem__>, '__setitem__': <function LeafNode.__setitem__>, '__delitem__': <function LeafNode.__delitem__>, '__contains__': <function LeafNode.__contains__>, '__dict__': <attribute '__dict__' of 'LeafNode' objects>, '__weakref__': <attribute '__weakref__' of 'LeafNode' objects>, '__attrs_attrs__': (Attribute(name='auth_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='auth_timeout'), Attribute(name='host', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='host'), Attribute(name='port', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='port'), Attribute(name='tls_timeout', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='tls_timeout'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function LeafNode.__repr__>, '__eq__': <function LeafNode.__eq__>, '__ne__': <function LeafNode.__ne__>, '__lt__': <function LeafNode.__lt__>, '__le__': <function LeafNode.__le__>, '__gt__': <function LeafNode.__gt__>, '__ge__': <function LeafNode.__ge__>, '__hash__': None, '__init__': <function LeafNode.__init__>, '__match_args__': ('auth_timeout', 'host', 'port', 'tls_timeout')})

LeafNode.__init__(auth_timeout=<kittycad.types.Unset object>, host=<kittycad.types.Unset object>, port=<kittycad.types.Unset object>, tls_timeout=<kittycad.types.Unset object>)

additional_properties (kittycad.models.leaf_node.LeafNode attribute)

__init__([auth_timeout, host, port, tls_timeout])

Method generated by attrs for class LeafNode.

rtype

TypeVar(TP, bound= LeafNode)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.leaf_node.LeafNode.__init__>`\ \(\[auth\_timeout\, host\, port\, tls\_timeout\]\)

:py:obj:`to_dict <kittycad.models.leaf_node.LeafNode.to_dict>`\ \(\)

host

port

{'additional_properties': typing.Dict[str, typing.Any], 'mesh': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='mesh', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mesh'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.mesh', '__annotations__': {'mesh': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, 'to_dict': <function Mesh.to_dict>, 'from_dict': <classmethod(<function Mesh.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Mesh.__getitem__>, '__setitem__': <function Mesh.__setitem__>, '__delitem__': <function Mesh.__delitem__>, '__contains__': <function Mesh.__contains__>, '__dict__': <attribute '__dict__' of 'Mesh' objects>, '__weakref__': <attribute '__weakref__' of 'Mesh' objects>, '__doc__': None, '__attrs_attrs__': (Attribute(name='mesh', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mesh'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Mesh.__repr__>, '__eq__': <function Mesh.__eq__>, '__ne__': <function Mesh.__ne__>, '__lt__': <function Mesh.__lt__>, '__le__': <function Mesh.__le__>, '__gt__': <function Mesh.__gt__>, '__ge__': <function Mesh.__ge__>, '__hash__': None, '__init__': <function Mesh.__init__>, '__match_args__': ('mesh',)})

__init__([mesh])

Method generated by attrs for class Mesh.

rtype

TypeVar(CF, bound= Mesh)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.mesh.Mesh.__init__>`\ \(\[mesh\]\)

:py:obj:`from_dict <kittycad.models.mesh.Mesh.from_dict>`\ \(src\_dict\)

MetaClusterInfo([cluster_size, leader, name])

:py:obj:`MetaClusterInfo <kittycad.models.meta_cluster_info.MetaClusterInfo>`\ \(\[cluster\_size\, leader\, name\]\)

MetaClusterInfo(cluster_size=<kittycad.types.Unset object>, leader=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

(cluster_size=<kittycad.types.Unset object>, leader=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'cluster_size': typing.Union[kittycad.types.Unset, int], 'leader': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

(Attribute(name='cluster_size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_size'), Attribute(name='leader', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leader'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__delitem__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__dict__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

mappingproxy({'__module__': 'kittycad.models.meta_cluster_info', '__annotations__': {'cluster_size': typing.Union[kittycad.types.Unset, int], 'leader': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Jetstream statistics.', 'to_dict': <function MetaClusterInfo.to_dict>, 'from_dict': <classmethod(<function MetaClusterInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function MetaClusterInfo.__getitem__>, '__setitem__': <function MetaClusterInfo.__setitem__>, '__delitem__': <function MetaClusterInfo.__delitem__>, '__contains__': <function MetaClusterInfo.__contains__>, '__dict__': <attribute '__dict__' of 'MetaClusterInfo' objects>, '__weakref__': <attribute '__weakref__' of 'MetaClusterInfo' objects>, '__attrs_attrs__': (Attribute(name='cluster_size', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cluster_size'), Attribute(name='leader', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='leader'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function MetaClusterInfo.__repr__>, '__eq__': <function MetaClusterInfo.__eq__>, '__ne__': <function MetaClusterInfo.__ne__>, '__lt__': <function MetaClusterInfo.__lt__>, '__le__': <function MetaClusterInfo.__le__>, '__gt__': <function MetaClusterInfo.__gt__>, '__ge__': <function MetaClusterInfo.__ge__>, '__hash__': None, '__init__': <function MetaClusterInfo.__init__>, '__match_args__': ('cluster_size', 'leader', 'name')})

__eq__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__ge__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__getitem__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__gt__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__hash__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

__init__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

MetaClusterInfo.__init__(cluster_size=<kittycad.types.Unset object>, leader=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__le__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__lt__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__match_args__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

__module__ (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

__ne__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__repr__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__setitem__() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

additional_keys (kittycad.models.meta_cluster_info.MetaClusterInfo property)

cluster_size (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

from_dict() (kittycad.models.meta_cluster_info.MetaClusterInfo class method)

leader (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

name (kittycad.models.meta_cluster_info.MetaClusterInfo attribute)

to_dict() (kittycad.models.meta_cluster_info.MetaClusterInfo method)

__init__([cluster_size, leader, name])

Method generated by attrs for class MetaClusterInfo.

rtype

TypeVar(OM, bound= MetaClusterInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.meta_cluster_info.MetaClusterInfo.__init__>`\ \(\[cluster\_size\, leader\, name\]\)

cluster_size

leader

name

Metadata([cache, engine, environment, ...])

:py:obj:`Metadata <kittycad.models.metadata.Metadata>`\ \(\[cache\, engine\, environment\, ...\]\)

Metadata(cache=<kittycad.types.Unset object>, engine=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, executor=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, point_e=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

(cache=<kittycad.types.Unset object>, engine=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, executor=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, point_e=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'cache': typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], 'engine': typing.Union[kittycad.types.Unset, kittycad.models.engine_metadata.EngineMetadata], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'executor': typing.Union[kittycad.types.Unset, kittycad.models.executor_metadata.ExecutorMetadata], 'fs': typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], 'git_hash': typing.Union[kittycad.types.Unset, str], 'point_e': typing.Union[kittycad.types.Unset, kittycad.models.point_e_metadata.PointEMetadata], 'pubsub': typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection]}

(Attribute(name='cache', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cache'), Attribute(name='engine', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.engine_metadata.EngineMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='engine'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='executor', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.executor_metadata.ExecutorMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='executor'), Attribute(name='fs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fs'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='point_e', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point_e_metadata.PointEMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='point_e'), Attribute(name='pubsub', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pubsub'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.metadata', '__annotations__': {'cache': typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], 'engine': typing.Union[kittycad.types.Unset, kittycad.models.engine_metadata.EngineMetadata], 'environment': typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], 'executor': typing.Union[kittycad.types.Unset, kittycad.models.executor_metadata.ExecutorMetadata], 'fs': typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], 'git_hash': typing.Union[kittycad.types.Unset, str], 'point_e': typing.Union[kittycad.types.Unset, kittycad.models.point_e_metadata.PointEMetadata], 'pubsub': typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our currently running server.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function Metadata.to_dict>, 'from_dict': <classmethod(<function Metadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Metadata.__getitem__>, '__setitem__': <function Metadata.__setitem__>, '__delitem__': <function Metadata.__delitem__>, '__contains__': <function Metadata.__contains__>, '__dict__': <attribute '__dict__' of 'Metadata' objects>, '__weakref__': <attribute '__weakref__' of 'Metadata' objects>, '__attrs_attrs__': (Attribute(name='cache', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.cache_metadata.CacheMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cache'), Attribute(name='engine', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.engine_metadata.EngineMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='engine'), Attribute(name='environment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.environment.Environment], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='environment'), Attribute(name='executor', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.executor_metadata.ExecutorMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='executor'), Attribute(name='fs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.file_system_metadata.FileSystemMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='fs'), Attribute(name='git_hash', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='git_hash'), Attribute(name='point_e', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point_e_metadata.PointEMetadata], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='point_e'), Attribute(name='pubsub', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.connection.Connection], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pubsub'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Metadata.__repr__>, '__eq__': <function Metadata.__eq__>, '__ne__': <function Metadata.__ne__>, '__lt__': <function Metadata.__lt__>, '__le__': <function Metadata.__le__>, '__gt__': <function Metadata.__gt__>, '__ge__': <function Metadata.__ge__>, '__hash__': None, '__init__': <function Metadata.__init__>, '__match_args__': ('cache', 'engine', 'environment', 'executor', 'fs', 'git_hash', 'point_e', 'pubsub')})

Metadata.__init__(cache=<kittycad.types.Unset object>, engine=<kittycad.types.Unset object>, environment=<kittycad.types.Unset object>, executor=<kittycad.types.Unset object>, fs=<kittycad.types.Unset object>, git_hash=<kittycad.types.Unset object>, point_e=<kittycad.types.Unset object>, pubsub=<kittycad.types.Unset object>)

('cache', 'engine', 'environment', 'executor', 'fs', 'git_hash', 'point_e', 'pubsub')

additional_properties (kittycad.models.metadata.Metadata attribute)

__init__([cache, engine, environment, ...])

Method generated by attrs for class Metadata.

rtype

TypeVar(EN, bound= Metadata)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.metadata.Metadata.__init__>`\ \(\[cache\, engine\, environment\, ...\]\)

:py:obj:`from_dict <kittycad.models.metadata.Metadata.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.metadata.Metadata.to_dict>`\ \(\)

cache

engine

executor

fs

git_hash

point_e

pubsub

Method(value[, names, module, qualname, ...])

The Request Method (VERB)

:py:obj:`Method <kittycad.models.method.Method>`\ \(value\[\, names\, module\, qualname\, ...\]\)

Method(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

This type also contains constants for a number of common HTTP methods such as GET, POST, etc.

Currently includes 8 variants representing the 8 methods defined in [RFC 7230](https://tools.ietf.org/html/rfc7231#section-4.1), plus PATCH, and an Extension variant for all extensions.

Currently includes 8 variants representing the 8 methods defined in [RFC 7230](

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.method', '__doc__': 'The Request Method (VERB)\n\n    This type also contains constants for a number of common HTTP methods such as GET, POST, etc.\n\n    Currently includes 8 variants representing the 8 methods defined in [RFC 7230](https://tools.ietf.org/html/rfc7231#section-4.1), plus PATCH, and an Extension variant for all extensions.\n    ', '__str__': <function Method.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['OPTIONS', 'GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'TRACE', 'CONNECT', 'PATCH', 'EXTENSION'], '_member_map_': {'OPTIONS': <Method.OPTIONS: 'OPTIONS'>, 'GET': <Method.GET: 'GET'>, 'POST': <Method.POST: 'POST'>, 'PUT': <Method.PUT: 'PUT'>, 'DELETE': <Method.DELETE: 'DELETE'>, 'HEAD': <Method.HEAD: 'HEAD'>, 'TRACE': <Method.TRACE: 'TRACE'>, 'CONNECT': <Method.CONNECT: 'CONNECT'>, 'PATCH': <Method.PATCH: 'PATCH'>, 'EXTENSION': <Method.EXTENSION: 'EXTENSION'>}, '_value2member_map_': {'OPTIONS': <Method.OPTIONS: 'OPTIONS'>, 'GET': <Method.GET: 'GET'>, 'POST': <Method.POST: 'POST'>, 'PUT': <Method.PUT: 'PUT'>, 'DELETE': <Method.DELETE: 'DELETE'>, 'HEAD': <Method.HEAD: 'HEAD'>, 'TRACE': <Method.TRACE: 'TRACE'>, 'CONNECT': <Method.CONNECT: 'CONNECT'>, 'PATCH': <Method.PATCH: 'PATCH'>, 'EXTENSION': <Method.EXTENSION: 'EXTENSION'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Method' objects>, '__weakref__': <attribute '__weakref__' of 'Method' objects>, 'OPTIONS': <Method.OPTIONS: 'OPTIONS'>, 'GET': <Method.GET: 'GET'>, 'POST': <Method.POST: 'POST'>, 'PUT': <Method.PUT: 'PUT'>, 'DELETE': <Method.DELETE: 'DELETE'>, 'HEAD': <Method.HEAD: 'HEAD'>, 'TRACE': <Method.TRACE: 'TRACE'>, 'CONNECT': <Method.CONNECT: 'CONNECT'>, 'PATCH': <Method.PATCH: 'PATCH'>, 'EXTENSION': <Method.EXTENSION: 'EXTENSION'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

{'CONNECT': Method.CONNECT, 'DELETE': Method.DELETE, 'EXTENSION': Method.EXTENSION, 'GET': Method.GET, 'HEAD': Method.HEAD, 'OPTIONS': Method.OPTIONS, 'PATCH': Method.PATCH, 'POST': Method.POST, 'PUT': Method.PUT, 'TRACE': Method.TRACE}

['OPTIONS', 'GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'TRACE', 'CONNECT', 'PATCH', 'EXTENSION']

:py:obj:`__init__ <kittycad.models.method.Method.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.method.Method.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.method.Method.casefold>`\ \(\)

:py:obj:`center <kittycad.models.method.Method.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.method.Method.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.method.Method.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.method.Method.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`expandtabs <kittycad.models.method.Method.expandtabs>`\ \(\[tabsize\]\)

:py:obj:`find <kittycad.models.method.Method.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.method.Method.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`format_map <kittycad.models.method.Method.format_map>`\ \(mapping\)

:py:obj:`index <kittycad.models.method.Method.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isdecimal <kittycad.models.method.Method.isdecimal>`\ \(\)

:py:obj:`isidentifier <kittycad.models.method.Method.isidentifier>`\ \(\)

:py:obj:`isnumeric <kittycad.models.method.Method.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.method.Method.isprintable>`\ \(\)

:py:obj:`join <kittycad.models.method.Method.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.method.Method.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lstrip <kittycad.models.method.Method.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.method.Method.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.method.Method.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.method.Method.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.method.Method.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.method.Method.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.method.Method.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.method.Method.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.method.Method.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.method.Method.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.method.Method.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.method.Method.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.method.Method.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.method.Method.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.method.Method.swapcase>`\ \(\)

:py:obj:`translate <kittycad.models.method.Method.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.method.Method.zfill>`\ \(width\, \/\)

OPTIONS

//tools.ietf.org/html/rfc7231#section-4.3.1).

GET

POST

PUT

//tools.ietf.org/html/rfc7231#section-4.3.5).

DELETE

//tools.ietf.org/html/rfc7231#section-4.3.2).

HEAD

//tools.ietf.org/html/rfc7231#section-4.3).

TRACE

//tools.ietf.org/html/rfc7231#section-4.3.6).

CONNECT

//tools.ietf.org/html/rfc5789).

PATCH

# A catch all.

EXTENSION

camera_drag_end([interaction, type, window])

Camera drag ended.

camera_drag_move([interaction, sequence, ...])

Camera drag continued.

camera_drag_start([interaction, type, window])

Camera drag started.

close_path([path_id, type])

Closes a path, converting it to a 2D solid.

default_camera_disable_sketch_mode([type])

Disable sketch mode, from the default camera.

default_camera_enable_sketch_mode([...])

Enable sketch mode, where users can sketch 2D geometry.

default_camera_look_at([center, type, up, ...])

Change what the default camera is looking at.

edit_mode_enter([target, type])

Enter edit mode

edit_mode_exit([type])

Exit edit mode

entity_get_all_child_uuids([entity_id, type])

What are all UUIDs of this entity's children?

entity_get_child_uuid([child_index, ...])

What is the UUID of this entity's n-th child?

entity_get_num_children([entity_id, type])

How many children does the entity have?

entity_get_parent_id([entity_id, type])

What is this entity's parent?

export([entity_ids, format, type])

Export the scene to a file.

extend_path([path, segment, type])

Extend a path by adding a new segment which starts at the path's "pen".

extrude([cap, distance, target, type])

Extrude a 2D solid.

get_entity_type([entity_id, type])

What type of entity is this?

highlight_set_entities([entities, type])

Changes the current highlighted entity to these entities.

highlight_set_entity([selected_at_window, ...])

Changes the current highlighted entity to whichever one is at the given window coordinate.

move_path_pen([path, to, type])

Move the path's "pen".

new_annotation([annotation_type, clobber, ...])

Create a new annotation

object_visible([hidden, object_id, type])

Hide or show an object

select_add([entities, type])

Adds one or more entities (by UUID) to the selection.

select_clear([type])

Clear the selection

select_get([type])

Find all IDs of selected entities

select_remove([entities, type])

Removes one or more entities (by UUID) from the selection.

select_replace([entities, type])

Replaces the current selection with these new entities (by UUID).

select_with_point([selected_at_window, ...])

Modifies the selection by simulating a "mouse click" at the given x,y window coordinate Returns ID of whatever was selected.

solid3d_get_all_edge_faces([edge_id, ...])

Gets all faces which use the given edge.

solid3d_get_all_opposite_edges([...])

Gets all edges which are opposite the given edge, across all possible faces.

solid3d_get_next_adjacent_edge([edge_id, ...])

Gets the next adjacent edge for the given edge, along the given face.

solid3d_get_opposite_edge([edge_id, ...])

Gets the edge opposite the given edge, along the given face.

solid3d_get_prev_adjacent_edge([edge_id, ...])

Gets the previous adjacent edge for the given edge, along the given face.

start_path([type])

Start a path.

update_annotation([annotation_id, options, type])

Update an annotation

:py:obj:`camera_drag_end <kittycad.models.modeling_cmd.camera_drag_end>`\ \(\[interaction\, type\, window\]\)

:py:obj:`camera_drag_move <kittycad.models.modeling_cmd.camera_drag_move>`\ \(\[interaction\, sequence\, ...\]\)

:py:obj:`camera_drag_start <kittycad.models.modeling_cmd.camera_drag_start>`\ \(\[interaction\, type\, window\]\)

:py:obj:`close_path <kittycad.models.modeling_cmd.close_path>`\ \(\[path\_id\, type\]\)

:py:obj:`default_camera_look_at <kittycad.models.modeling_cmd.default_camera_look_at>`\ \(\[center\, type\, up\, ...\]\)

:py:obj:`edit_mode_enter <kittycad.models.modeling_cmd.edit_mode_enter>`\ \(\[target\, type\]\)

:py:obj:`entity_get_child_uuid <kittycad.models.modeling_cmd.entity_get_child_uuid>`\ \(\[child\_index\, ...\]\)

:py:obj:`entity_get_num_children <kittycad.models.modeling_cmd.entity_get_num_children>`\ \(\[entity\_id\, type\]\)

:py:obj:`entity_get_parent_id <kittycad.models.modeling_cmd.entity_get_parent_id>`\ \(\[entity\_id\, type\]\)

:py:obj:`export <kittycad.models.modeling_cmd.export>`\ \(\[entity\_ids\, format\, type\]\)

:py:obj:`extend_path <kittycad.models.modeling_cmd.extend_path>`\ \(\[path\, segment\, type\]\)

:py:obj:`extrude <kittycad.models.modeling_cmd.extrude>`\ \(\[cap\, distance\, target\, type\]\)

:py:obj:`get_entity_type <kittycad.models.modeling_cmd.get_entity_type>`\ \(\[entity\_id\, type\]\)

:py:obj:`highlight_set_entities <kittycad.models.modeling_cmd.highlight_set_entities>`\ \(\[entities\, type\]\)

:py:obj:`highlight_set_entity <kittycad.models.modeling_cmd.highlight_set_entity>`\ \(\[selected\_at\_window\, ...\]\)

:py:obj:`move_path_pen <kittycad.models.modeling_cmd.move_path_pen>`\ \(\[path\, to\, type\]\)

:py:obj:`new_annotation <kittycad.models.modeling_cmd.new_annotation>`\ \(\[annotation\_type\, clobber\, ...\]\)

:py:obj:`object_visible <kittycad.models.modeling_cmd.object_visible>`\ \(\[hidden\, object\_id\, type\]\)

:py:obj:`select_add <kittycad.models.modeling_cmd.select_add>`\ \(\[entities\, type\]\)

:py:obj:`select_clear <kittycad.models.modeling_cmd.select_clear>`\ \(\[type\]\)

:py:obj:`select_get <kittycad.models.modeling_cmd.select_get>`\ \(\[type\]\)

:py:obj:`select_remove <kittycad.models.modeling_cmd.select_remove>`\ \(\[entities\, type\]\)

:py:obj:`select_replace <kittycad.models.modeling_cmd.select_replace>`\ \(\[entities\, type\]\)

:py:obj:`select_with_point <kittycad.models.modeling_cmd.select_with_point>`\ \(\[selected\_at\_window\, ...\]\)

:py:obj:`solid3d_get_all_edge_faces <kittycad.models.modeling_cmd.solid3d_get_all_edge_faces>`\ \(\[edge\_id\, ...\]\)

:py:obj:`solid3d_get_opposite_edge <kittycad.models.modeling_cmd.solid3d_get_opposite_edge>`\ \(\[edge\_id\, ...\]\)

:py:obj:`start_path <kittycad.models.modeling_cmd.start_path>`\ \(\[type\]\)

:py:obj:`update_annotation <kittycad.models.modeling_cmd.update_annotation>`\ \(\[annotation\_id\, options\, type\]\)

camera_drag_end(interaction=<kittycad.types.Unset object>, type='camera_drag_end', window=<kittycad.types.Unset object>)

(interaction=<kittycad.types.Unset object>, type='camera_drag_end', window=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'interaction': typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], 'type': <class 'str'>, 'window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d]}

__attrs_attrs__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

(Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='type', default='camera_drag_end', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.camera_drag_end method)

__delitem__() (kittycad.models.modeling_cmd.camera_drag_end method)

__dict__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'interaction': typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], 'type': <class 'str'>, 'window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Camera drag ended.', 'to_dict': <function camera_drag_end.to_dict>, 'from_dict': <classmethod(<function camera_drag_end.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function camera_drag_end.__getitem__>, '__setitem__': <function camera_drag_end.__setitem__>, '__delitem__': <function camera_drag_end.__delitem__>, '__contains__': <function camera_drag_end.__contains__>, '__dict__': <attribute '__dict__' of 'camera_drag_end' objects>, '__weakref__': <attribute '__weakref__' of 'camera_drag_end' objects>, '__attrs_attrs__': (Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='type', default='camera_drag_end', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function camera_drag_end.__repr__>, '__eq__': <function camera_drag_end.__eq__>, '__ne__': <function camera_drag_end.__ne__>, '__lt__': <function camera_drag_end.__lt__>, '__le__': <function camera_drag_end.__le__>, '__gt__': <function camera_drag_end.__gt__>, '__ge__': <function camera_drag_end.__ge__>, '__hash__': None, '__init__': <function camera_drag_end.__init__>, '__match_args__': ('interaction', 'type', 'window')})

__getitem__() (kittycad.models.modeling_cmd.camera_drag_end method)

__hash__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

__init__() (kittycad.models.modeling_cmd.camera_drag_end method)

camera_drag_end.__init__(interaction=<kittycad.types.Unset object>, type='camera_drag_end', window=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

__module__ (kittycad.models.modeling_cmd.camera_drag_end attribute)

__repr__() (kittycad.models.modeling_cmd.camera_drag_end method)

__setitem__() (kittycad.models.modeling_cmd.camera_drag_end method)

additional_keys (kittycad.models.modeling_cmd.camera_drag_end property)

additional_properties (kittycad.models.modeling_cmd.camera_drag_end attribute)

from_dict() (kittycad.models.modeling_cmd.camera_drag_end class method)

interaction (kittycad.models.modeling_cmd.camera_drag_end attribute)

camera_drag_move(interaction=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='camera_drag_move', window=<kittycad.types.Unset object>)

(interaction=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='camera_drag_move', window=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'interaction': typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>, 'window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d]}

__attrs_attrs__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

(Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='camera_drag_move', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.camera_drag_move method)

__delitem__() (kittycad.models.modeling_cmd.camera_drag_move method)

__dict__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'interaction': typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>, 'window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Camera drag continued.', 'to_dict': <function camera_drag_move.to_dict>, 'from_dict': <classmethod(<function camera_drag_move.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function camera_drag_move.__getitem__>, '__setitem__': <function camera_drag_move.__setitem__>, '__delitem__': <function camera_drag_move.__delitem__>, '__contains__': <function camera_drag_move.__contains__>, '__dict__': <attribute '__dict__' of 'camera_drag_move' objects>, '__weakref__': <attribute '__weakref__' of 'camera_drag_move' objects>, '__attrs_attrs__': (Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='camera_drag_move', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function camera_drag_move.__repr__>, '__eq__': <function camera_drag_move.__eq__>, '__ne__': <function camera_drag_move.__ne__>, '__lt__': <function camera_drag_move.__lt__>, '__le__': <function camera_drag_move.__le__>, '__gt__': <function camera_drag_move.__gt__>, '__ge__': <function camera_drag_move.__ge__>, '__hash__': None, '__init__': <function camera_drag_move.__init__>, '__match_args__': ('interaction', 'sequence', 'type', 'window')})

__getitem__() (kittycad.models.modeling_cmd.camera_drag_move method)

__hash__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

__init__() (kittycad.models.modeling_cmd.camera_drag_move method)

camera_drag_move.__init__(interaction=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='camera_drag_move', window=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

__module__ (kittycad.models.modeling_cmd.camera_drag_move attribute)

__repr__() (kittycad.models.modeling_cmd.camera_drag_move method)

__setitem__() (kittycad.models.modeling_cmd.camera_drag_move method)

additional_keys (kittycad.models.modeling_cmd.camera_drag_move property)

additional_properties (kittycad.models.modeling_cmd.camera_drag_move attribute)

from_dict() (kittycad.models.modeling_cmd.camera_drag_move class method)

interaction (kittycad.models.modeling_cmd.camera_drag_move attribute)

sequence (kittycad.models.modeling_cmd.camera_drag_move attribute)

to_dict() (kittycad.models.modeling_cmd.camera_drag_move method)

window (kittycad.models.modeling_cmd.camera_drag_move attribute)

camera_drag_start(interaction=<kittycad.types.Unset object>, type='camera_drag_start', window=<kittycad.types.Unset object>)

(interaction=<kittycad.types.Unset object>, type='camera_drag_start', window=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

(Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='type', default='camera_drag_start', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.camera_drag_start method)

__delitem__() (kittycad.models.modeling_cmd.camera_drag_start method)

__dict__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'interaction': typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], 'type': <class 'str'>, 'window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Camera drag started.', 'to_dict': <function camera_drag_start.to_dict>, 'from_dict': <classmethod(<function camera_drag_start.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function camera_drag_start.__getitem__>, '__setitem__': <function camera_drag_start.__setitem__>, '__delitem__': <function camera_drag_start.__delitem__>, '__contains__': <function camera_drag_start.__contains__>, '__dict__': <attribute '__dict__' of 'camera_drag_start' objects>, '__weakref__': <attribute '__weakref__' of 'camera_drag_start' objects>, '__attrs_attrs__': (Attribute(name='interaction', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.camera_drag_interaction_type.CameraDragInteractionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='interaction'), Attribute(name='type', default='camera_drag_start', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='window'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function camera_drag_start.__repr__>, '__eq__': <function camera_drag_start.__eq__>, '__ne__': <function camera_drag_start.__ne__>, '__lt__': <function camera_drag_start.__lt__>, '__le__': <function camera_drag_start.__le__>, '__gt__': <function camera_drag_start.__gt__>, '__ge__': <function camera_drag_start.__ge__>, '__hash__': None, '__init__': <function camera_drag_start.__init__>, '__match_args__': ('interaction', 'type', 'window')})

__eq__() (kittycad.models.modeling_cmd.camera_drag_start method)

__ge__() (kittycad.models.modeling_cmd.camera_drag_start method)

__getitem__() (kittycad.models.modeling_cmd.camera_drag_start method)

__gt__() (kittycad.models.modeling_cmd.camera_drag_start method)

__hash__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

__init__() (kittycad.models.modeling_cmd.camera_drag_start method)

camera_drag_start.__init__(interaction=<kittycad.types.Unset object>, type='camera_drag_start', window=<kittycad.types.Unset object>)

__le__() (kittycad.models.modeling_cmd.camera_drag_start method)

__lt__() (kittycad.models.modeling_cmd.camera_drag_start method)

__match_args__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

__module__ (kittycad.models.modeling_cmd.camera_drag_start attribute)

__ne__() (kittycad.models.modeling_cmd.camera_drag_start method)

__repr__() (kittycad.models.modeling_cmd.camera_drag_start method)

__setitem__() (kittycad.models.modeling_cmd.camera_drag_start method)

additional_keys (kittycad.models.modeling_cmd.camera_drag_start property)

additional_properties (kittycad.models.modeling_cmd.camera_drag_start attribute)

from_dict() (kittycad.models.modeling_cmd.camera_drag_start class method)

interaction (kittycad.models.modeling_cmd.camera_drag_start attribute)

to_dict() (kittycad.models.modeling_cmd.camera_drag_start method)

window (kittycad.models.modeling_cmd.camera_drag_start attribute)

close_path(path_id=<kittycad.types.Unset object>, type='close_path')

__annotations__ (kittycad.models.modeling_cmd.close_path attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'path_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.close_path attribute)

(Attribute(name='path_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path_id'), Attribute(name='type', default='close_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'path_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Closes a path, converting it to a 2D solid.', 'to_dict': <function close_path.to_dict>, 'from_dict': <classmethod(<function close_path.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function close_path.__getitem__>, '__setitem__': <function close_path.__setitem__>, '__delitem__': <function close_path.__delitem__>, '__contains__': <function close_path.__contains__>, '__dict__': <attribute '__dict__' of 'close_path' objects>, '__weakref__': <attribute '__weakref__' of 'close_path' objects>, '__attrs_attrs__': (Attribute(name='path_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path_id'), Attribute(name='type', default='close_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function close_path.__repr__>, '__eq__': <function close_path.__eq__>, '__ne__': <function close_path.__ne__>, '__lt__': <function close_path.__lt__>, '__le__': <function close_path.__le__>, '__gt__': <function close_path.__gt__>, '__ge__': <function close_path.__ge__>, '__hash__': None, '__init__': <function close_path.__init__>, '__match_args__': ('path_id', 'type')})

close_path.__init__(path_id=<kittycad.types.Unset object>, type='close_path')

__match_args__ (kittycad.models.modeling_cmd.close_path attribute)

additional_keys (kittycad.models.modeling_cmd.close_path property)

additional_properties (kittycad.models.modeling_cmd.close_path attribute)

from_dict() (kittycad.models.modeling_cmd.close_path class method)

default_camera_disable_sketch_mode (class in kittycad.models.modeling_cmd)

Method generated by attrs for class default_camera_disable_sketch_mode.

(Attribute(name='type', default='default_camera_disable_sketch_mode', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Disable sketch mode, from the default camera.', 'to_dict': <function default_camera_disable_sketch_mode.to_dict>, 'from_dict': <classmethod(<function default_camera_disable_sketch_mode.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function default_camera_disable_sketch_mode.__getitem__>, '__setitem__': <function default_camera_disable_sketch_mode.__setitem__>, '__delitem__': <function default_camera_disable_sketch_mode.__delitem__>, '__contains__': <function default_camera_disable_sketch_mode.__contains__>, '__dict__': <attribute '__dict__' of 'default_camera_disable_sketch_mode' objects>, '__weakref__': <attribute '__weakref__' of 'default_camera_disable_sketch_mode' objects>, '__attrs_attrs__': (Attribute(name='type', default='default_camera_disable_sketch_mode', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function default_camera_disable_sketch_mode.__repr__>, '__eq__': <function default_camera_disable_sketch_mode.__eq__>, '__ne__': <function default_camera_disable_sketch_mode.__ne__>, '__lt__': <function default_camera_disable_sketch_mode.__lt__>, '__le__': <function default_camera_disable_sketch_mode.__le__>, '__gt__': <function default_camera_disable_sketch_mode.__gt__>, '__ge__': <function default_camera_disable_sketch_mode.__ge__>, '__hash__': None, '__init__': <function default_camera_disable_sketch_mode.__init__>, '__match_args__': ('type',)})

from_dict() (kittycad.models.modeling_cmd.default_camera_disable_sketch_mode class method)

type (kittycad.models.modeling_cmd.default_camera_disable_sketch_mode attribute)

default_camera_enable_sketch_mode (class in kittycad.models.modeling_cmd)

default_camera_enable_sketch_mode(animated=False, distance_to_plane=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, ortho=False, type='default_camera_enable_sketch_mode', x_axis=<kittycad.types.Unset object>, y_axis=<kittycad.types.Unset object>)

(animated=False, distance_to_plane=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, ortho=False, type='default_camera_enable_sketch_mode', x_axis=<kittycad.types.Unset object>, y_axis=<kittycad.types.Unset object>)

Enable sketch mode, where users can sketch 2D geometry. Users choose a plane to sketch on.

Method generated by attrs for class default_camera_enable_sketch_mode.

{'additional_properties': typing.Dict[str, typing.Any], 'animated': typing.Union[kittycad.types.Unset, bool], 'distance_to_plane': typing.Union[kittycad.types.Unset, float], 'origin': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'ortho': typing.Union[kittycad.types.Unset, bool], 'type': <class 'str'>, 'x_axis': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'y_axis': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d]}

(Attribute(name='animated', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='animated'), Attribute(name='distance_to_plane', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='distance_to_plane'), Attribute(name='origin', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='origin'), Attribute(name='ortho', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ortho'), Attribute(name='type', default='default_camera_enable_sketch_mode', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='x_axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x_axis'), Attribute(name='y_axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y_axis'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'animated': typing.Union[kittycad.types.Unset, bool], 'distance_to_plane': typing.Union[kittycad.types.Unset, float], 'origin': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'ortho': typing.Union[kittycad.types.Unset, bool], 'type': <class 'str'>, 'x_axis': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'y_axis': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Enable sketch mode, where users can sketch 2D geometry. Users choose a plane to sketch on.', 'to_dict': <function default_camera_enable_sketch_mode.to_dict>, 'from_dict': <classmethod(<function default_camera_enable_sketch_mode.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function default_camera_enable_sketch_mode.__getitem__>, '__setitem__': <function default_camera_enable_sketch_mode.__setitem__>, '__delitem__': <function default_camera_enable_sketch_mode.__delitem__>, '__contains__': <function default_camera_enable_sketch_mode.__contains__>, '__dict__': <attribute '__dict__' of 'default_camera_enable_sketch_mode' objects>, '__weakref__': <attribute '__weakref__' of 'default_camera_enable_sketch_mode' objects>, '__attrs_attrs__': (Attribute(name='animated', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='animated'), Attribute(name='distance_to_plane', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='distance_to_plane'), Attribute(name='origin', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='origin'), Attribute(name='ortho', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ortho'), Attribute(name='type', default='default_camera_enable_sketch_mode', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='x_axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x_axis'), Attribute(name='y_axis', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y_axis'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function default_camera_enable_sketch_mode.__repr__>, '__eq__': <function default_camera_enable_sketch_mode.__eq__>, '__ne__': <function default_camera_enable_sketch_mode.__ne__>, '__lt__': <function default_camera_enable_sketch_mode.__lt__>, '__le__': <function default_camera_enable_sketch_mode.__le__>, '__gt__': <function default_camera_enable_sketch_mode.__gt__>, '__ge__': <function default_camera_enable_sketch_mode.__ge__>, '__hash__': None, '__init__': <function default_camera_enable_sketch_mode.__init__>, '__match_args__': ('animated', 'distance_to_plane', 'origin', 'ortho', 'type', 'x_axis', 'y_axis')})

__eq__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

__ge__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

__gt__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

default_camera_enable_sketch_mode.__init__(animated=False, distance_to_plane=<kittycad.types.Unset object>, origin=<kittycad.types.Unset object>, ortho=False, type='default_camera_enable_sketch_mode', x_axis=<kittycad.types.Unset object>, y_axis=<kittycad.types.Unset object>)

__le__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

__lt__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

('animated', 'distance_to_plane', 'origin', 'ortho', 'type', 'x_axis', 'y_axis')

__ne__() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode method)

from_dict() (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode class method)

ortho (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode attribute)

type (kittycad.models.modeling_cmd.default_camera_enable_sketch_mode attribute)

default_camera_look_at(center=<kittycad.types.Unset object>, type='default_camera_look_at', up=<kittycad.types.Unset object>, vantage=<kittycad.types.Unset object>)

(center=<kittycad.types.Unset object>, type='default_camera_look_at', up=<kittycad.types.Unset object>, vantage=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'center': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>, 'up': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'vantage': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d]}

__attrs_attrs__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

(Attribute(name='center', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center'), Attribute(name='type', default='default_camera_look_at', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='up', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='up'), Attribute(name='vantage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='vantage'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__delitem__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__dict__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'center': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>, 'up': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'vantage': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Change what the default camera is looking at.', 'to_dict': <function default_camera_look_at.to_dict>, 'from_dict': <classmethod(<function default_camera_look_at.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function default_camera_look_at.__getitem__>, '__setitem__': <function default_camera_look_at.__setitem__>, '__delitem__': <function default_camera_look_at.__delitem__>, '__contains__': <function default_camera_look_at.__contains__>, '__dict__': <attribute '__dict__' of 'default_camera_look_at' objects>, '__weakref__': <attribute '__weakref__' of 'default_camera_look_at' objects>, '__attrs_attrs__': (Attribute(name='center', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center'), Attribute(name='type', default='default_camera_look_at', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='up', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='up'), Attribute(name='vantage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='vantage'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function default_camera_look_at.__repr__>, '__eq__': <function default_camera_look_at.__eq__>, '__ne__': <function default_camera_look_at.__ne__>, '__lt__': <function default_camera_look_at.__lt__>, '__le__': <function default_camera_look_at.__le__>, '__gt__': <function default_camera_look_at.__gt__>, '__ge__': <function default_camera_look_at.__ge__>, '__hash__': None, '__init__': <function default_camera_look_at.__init__>, '__match_args__': ('center', 'type', 'up', 'vantage')})

__eq__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__ge__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__getitem__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__gt__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__hash__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

__init__() (kittycad.models.modeling_cmd.default_camera_look_at method)

default_camera_look_at.__init__(center=<kittycad.types.Unset object>, type='default_camera_look_at', up=<kittycad.types.Unset object>, vantage=<kittycad.types.Unset object>)

__le__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__lt__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__match_args__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

__module__ (kittycad.models.modeling_cmd.default_camera_look_at attribute)

__ne__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__repr__() (kittycad.models.modeling_cmd.default_camera_look_at method)

__setitem__() (kittycad.models.modeling_cmd.default_camera_look_at method)

additional_keys (kittycad.models.modeling_cmd.default_camera_look_at property)

center (kittycad.models.modeling_cmd.default_camera_look_at attribute)

from_dict() (kittycad.models.modeling_cmd.default_camera_look_at class method)

to_dict() (kittycad.models.modeling_cmd.default_camera_look_at method)

type (kittycad.models.modeling_cmd.default_camera_look_at attribute)

up (kittycad.models.modeling_cmd.default_camera_look_at attribute)

vantage (kittycad.models.modeling_cmd.default_camera_look_at attribute)

edit_mode_enter(target=<kittycad.types.Unset object>, type='edit_mode_enter')

__annotations__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'target': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

(Attribute(name='target', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='target'), Attribute(name='type', default='edit_mode_enter', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.edit_mode_enter method)

__delitem__() (kittycad.models.modeling_cmd.edit_mode_enter method)

__dict__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'target': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Enter edit mode', 'to_dict': <function edit_mode_enter.to_dict>, 'from_dict': <classmethod(<function edit_mode_enter.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function edit_mode_enter.__getitem__>, '__setitem__': <function edit_mode_enter.__setitem__>, '__delitem__': <function edit_mode_enter.__delitem__>, '__contains__': <function edit_mode_enter.__contains__>, '__dict__': <attribute '__dict__' of 'edit_mode_enter' objects>, '__weakref__': <attribute '__weakref__' of 'edit_mode_enter' objects>, '__attrs_attrs__': (Attribute(name='target', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='target'), Attribute(name='type', default='edit_mode_enter', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function edit_mode_enter.__repr__>, '__eq__': <function edit_mode_enter.__eq__>, '__ne__': <function edit_mode_enter.__ne__>, '__lt__': <function edit_mode_enter.__lt__>, '__le__': <function edit_mode_enter.__le__>, '__gt__': <function edit_mode_enter.__gt__>, '__ge__': <function edit_mode_enter.__ge__>, '__hash__': None, '__init__': <function edit_mode_enter.__init__>, '__match_args__': ('target', 'type')})

__getitem__() (kittycad.models.modeling_cmd.edit_mode_enter method)

__hash__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

__init__() (kittycad.models.modeling_cmd.edit_mode_enter method)

__match_args__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

__module__ (kittycad.models.modeling_cmd.edit_mode_enter attribute)

__repr__() (kittycad.models.modeling_cmd.edit_mode_enter method)

__setitem__() (kittycad.models.modeling_cmd.edit_mode_enter method)

additional_keys (kittycad.models.modeling_cmd.edit_mode_enter property)

additional_properties (kittycad.models.modeling_cmd.edit_mode_enter attribute)

from_dict() (kittycad.models.modeling_cmd.edit_mode_enter class method)

__annotations__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

(Attribute(name='type', default='edit_mode_exit', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.edit_mode_exit method)

__delitem__() (kittycad.models.modeling_cmd.edit_mode_exit method)

__dict__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Exit edit mode', 'to_dict': <function edit_mode_exit.to_dict>, 'from_dict': <classmethod(<function edit_mode_exit.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function edit_mode_exit.__getitem__>, '__setitem__': <function edit_mode_exit.__setitem__>, '__delitem__': <function edit_mode_exit.__delitem__>, '__contains__': <function edit_mode_exit.__contains__>, '__dict__': <attribute '__dict__' of 'edit_mode_exit' objects>, '__weakref__': <attribute '__weakref__' of 'edit_mode_exit' objects>, '__attrs_attrs__': (Attribute(name='type', default='edit_mode_exit', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function edit_mode_exit.__repr__>, '__eq__': <function edit_mode_exit.__eq__>, '__ne__': <function edit_mode_exit.__ne__>, '__lt__': <function edit_mode_exit.__lt__>, '__le__': <function edit_mode_exit.__le__>, '__gt__': <function edit_mode_exit.__gt__>, '__ge__': <function edit_mode_exit.__ge__>, '__hash__': None, '__init__': <function edit_mode_exit.__init__>, '__match_args__': ('type',)})

__getitem__() (kittycad.models.modeling_cmd.edit_mode_exit method)

__hash__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

__match_args__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

__module__ (kittycad.models.modeling_cmd.edit_mode_exit attribute)

__setitem__() (kittycad.models.modeling_cmd.edit_mode_exit method)

additional_keys (kittycad.models.modeling_cmd.edit_mode_exit property)

additional_properties (kittycad.models.modeling_cmd.edit_mode_exit attribute)

from_dict() (kittycad.models.modeling_cmd.edit_mode_exit class method)

entity_get_all_child_uuids (class in kittycad.models.modeling_cmd)

(entity_id=<kittycad.types.Unset object>, type='entity_get_all_child_uuids')

{'additional_properties': typing.Dict[str, typing.Any], 'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_all_child_uuids', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__delitem__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__dict__ (kittycad.models.modeling_cmd.entity_get_all_child_uuids attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "What are all UUIDs of this entity's children?", 'to_dict': <function entity_get_all_child_uuids.to_dict>, 'from_dict': <classmethod(<function entity_get_all_child_uuids.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_all_child_uuids.__getitem__>, '__setitem__': <function entity_get_all_child_uuids.__setitem__>, '__delitem__': <function entity_get_all_child_uuids.__delitem__>, '__contains__': <function entity_get_all_child_uuids.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_all_child_uuids' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_all_child_uuids' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_all_child_uuids', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_all_child_uuids.__repr__>, '__eq__': <function entity_get_all_child_uuids.__eq__>, '__ne__': <function entity_get_all_child_uuids.__ne__>, '__lt__': <function entity_get_all_child_uuids.__lt__>, '__le__': <function entity_get_all_child_uuids.__le__>, '__gt__': <function entity_get_all_child_uuids.__gt__>, '__ge__': <function entity_get_all_child_uuids.__ge__>, '__hash__': None, '__init__': <function entity_get_all_child_uuids.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__ge__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__getitem__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__gt__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__hash__ (kittycad.models.modeling_cmd.entity_get_all_child_uuids attribute)

__init__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__le__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__lt__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__module__ (kittycad.models.modeling_cmd.entity_get_all_child_uuids attribute)

__ne__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__repr__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

__setitem__() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

entity_id (kittycad.models.modeling_cmd.entity_get_all_child_uuids attribute)

from_dict() (kittycad.models.modeling_cmd.entity_get_all_child_uuids class method)

to_dict() (kittycad.models.modeling_cmd.entity_get_all_child_uuids method)

type (kittycad.models.modeling_cmd.entity_get_all_child_uuids attribute)

entity_get_child_uuid(child_index=<kittycad.types.Unset object>, entity_id=<kittycad.types.Unset object>, type='entity_get_child_uuid')

(child_index=<kittycad.types.Unset object>, entity_id=<kittycad.types.Unset object>, type='entity_get_child_uuid')

__annotations__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'child_index': typing.Union[kittycad.types.Unset, int], 'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

(Attribute(name='child_index', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='child_index'), Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_child_uuid', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__delitem__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__dict__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'child_index': typing.Union[kittycad.types.Unset, int], 'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "What is the UUID of this entity's n-th child?", 'to_dict': <function entity_get_child_uuid.to_dict>, 'from_dict': <classmethod(<function entity_get_child_uuid.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_child_uuid.__getitem__>, '__setitem__': <function entity_get_child_uuid.__setitem__>, '__delitem__': <function entity_get_child_uuid.__delitem__>, '__contains__': <function entity_get_child_uuid.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_child_uuid' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_child_uuid' objects>, '__attrs_attrs__': (Attribute(name='child_index', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='child_index'), Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_child_uuid', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_child_uuid.__repr__>, '__eq__': <function entity_get_child_uuid.__eq__>, '__ne__': <function entity_get_child_uuid.__ne__>, '__lt__': <function entity_get_child_uuid.__lt__>, '__le__': <function entity_get_child_uuid.__le__>, '__gt__': <function entity_get_child_uuid.__gt__>, '__ge__': <function entity_get_child_uuid.__ge__>, '__hash__': None, '__init__': <function entity_get_child_uuid.__init__>, '__match_args__': ('child_index', 'entity_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__ge__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__getitem__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__gt__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__hash__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

__init__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

entity_get_child_uuid.__init__(child_index=<kittycad.types.Unset object>, entity_id=<kittycad.types.Unset object>, type='entity_get_child_uuid')

__le__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__lt__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__match_args__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

__module__ (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

__ne__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__repr__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

__setitem__() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

additional_keys (kittycad.models.modeling_cmd.entity_get_child_uuid property)

child_index (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

entity_id (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

from_dict() (kittycad.models.modeling_cmd.entity_get_child_uuid class method)

to_dict() (kittycad.models.modeling_cmd.entity_get_child_uuid method)

type (kittycad.models.modeling_cmd.entity_get_child_uuid attribute)

(entity_id=<kittycad.types.Unset object>, type='entity_get_num_children')

__annotations__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_num_children', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__delitem__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__dict__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'How many children does the entity have?', 'to_dict': <function entity_get_num_children.to_dict>, 'from_dict': <classmethod(<function entity_get_num_children.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_num_children.__getitem__>, '__setitem__': <function entity_get_num_children.__setitem__>, '__delitem__': <function entity_get_num_children.__delitem__>, '__contains__': <function entity_get_num_children.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_num_children' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_num_children' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_num_children', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_num_children.__repr__>, '__eq__': <function entity_get_num_children.__eq__>, '__ne__': <function entity_get_num_children.__ne__>, '__lt__': <function entity_get_num_children.__lt__>, '__le__': <function entity_get_num_children.__le__>, '__gt__': <function entity_get_num_children.__gt__>, '__ge__': <function entity_get_num_children.__ge__>, '__hash__': None, '__init__': <function entity_get_num_children.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__ge__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__getitem__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__gt__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__hash__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

__init__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__le__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__lt__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__match_args__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

__module__ (kittycad.models.modeling_cmd.entity_get_num_children attribute)

__ne__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__repr__() (kittycad.models.modeling_cmd.entity_get_num_children method)

__setitem__() (kittycad.models.modeling_cmd.entity_get_num_children method)

additional_keys (kittycad.models.modeling_cmd.entity_get_num_children property)

entity_id (kittycad.models.modeling_cmd.entity_get_num_children attribute)

from_dict() (kittycad.models.modeling_cmd.entity_get_num_children class method)

to_dict() (kittycad.models.modeling_cmd.entity_get_num_children method)

type (kittycad.models.modeling_cmd.entity_get_num_children attribute)

(entity_id=<kittycad.types.Unset object>, type='entity_get_parent_id')

__annotations__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_parent_id', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__delitem__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__dict__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "What is this entity's parent?", 'to_dict': <function entity_get_parent_id.to_dict>, 'from_dict': <classmethod(<function entity_get_parent_id.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_parent_id.__getitem__>, '__setitem__': <function entity_get_parent_id.__setitem__>, '__delitem__': <function entity_get_parent_id.__delitem__>, '__contains__': <function entity_get_parent_id.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_parent_id' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_parent_id' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_parent_id', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_parent_id.__repr__>, '__eq__': <function entity_get_parent_id.__eq__>, '__ne__': <function entity_get_parent_id.__ne__>, '__lt__': <function entity_get_parent_id.__lt__>, '__le__': <function entity_get_parent_id.__le__>, '__gt__': <function entity_get_parent_id.__gt__>, '__ge__': <function entity_get_parent_id.__ge__>, '__hash__': None, '__init__': <function entity_get_parent_id.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__ge__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__getitem__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__gt__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__hash__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

__init__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__le__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__lt__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__match_args__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

__module__ (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

__ne__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__repr__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

__setitem__() (kittycad.models.modeling_cmd.entity_get_parent_id method)

additional_keys (kittycad.models.modeling_cmd.entity_get_parent_id property)

entity_id (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

from_dict() (kittycad.models.modeling_cmd.entity_get_parent_id class method)

to_dict() (kittycad.models.modeling_cmd.entity_get_parent_id method)

type (kittycad.models.modeling_cmd.entity_get_parent_id attribute)

export(entity_ids=<kittycad.types.Unset object>, format=<kittycad.types.Unset object>, type='export')

(entity_ids=<kittycad.types.Unset object>, format=<kittycad.types.Unset object>, type='export')

{'additional_properties': typing.Dict[str, typing.Any], 'entity_ids': typing.Union[kittycad.types.Unset, typing.List[str]], 'format': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'type': <class 'str'>}

(Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='format'), Attribute(name='type', default='export', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entity_ids': typing.Union[kittycad.types.Unset, typing.List[str]], 'format': typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Export the scene to a file.', 'to_dict': <function export.to_dict>, 'from_dict': <classmethod(<function export.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function export.__getitem__>, '__setitem__': <function export.__setitem__>, '__delitem__': <function export.__delitem__>, '__contains__': <function export.__contains__>, '__dict__': <attribute '__dict__' of 'export' objects>, '__weakref__': <attribute '__weakref__' of 'export' objects>, '__attrs_attrs__': (Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='format', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.output_format.gltf, kittycad.models.output_format.obj, kittycad.models.output_format.ply, kittycad.models.output_format.step, kittycad.models.output_format.stl], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='format'), Attribute(name='type', default='export', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function export.__repr__>, '__eq__': <function export.__eq__>, '__ne__': <function export.__ne__>, '__lt__': <function export.__lt__>, '__le__': <function export.__le__>, '__gt__': <function export.__gt__>, '__ge__': <function export.__ge__>, '__hash__': None, '__init__': <function export.__init__>, '__match_args__': ('entity_ids', 'format', 'type')})

export.__init__(entity_ids=<kittycad.types.Unset object>, format=<kittycad.types.Unset object>, type='export')

additional_properties (kittycad.models.modeling_cmd.export attribute)

extend_path(path=<kittycad.types.Unset object>, segment=<kittycad.types.Unset object>, type='extend_path')

(path=<kittycad.types.Unset object>, segment=<kittycad.types.Unset object>, type='extend_path')

Extend a path by adding a new segment which starts at the path's "pen". If no "pen" location has been set before (via `MovePen`), then the pen is at the origin.

Extend a path by adding a new segment which starts at the path’s “pen”. If no “pen” location has been set before (via 

__annotations__ (kittycad.models.modeling_cmd.extend_path attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'path': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'segment': typing.Union[kittycad.types.Unset, kittycad.models.path_segment.line, kittycad.models.path_segment.arc, kittycad.models.path_segment.bezier], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.extend_path attribute)

(Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='segment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.path_segment.line, kittycad.models.path_segment.arc, kittycad.models.path_segment.bezier], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='segment'), Attribute(name='type', default='extend_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.extend_path method)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'path': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'segment': typing.Union[kittycad.types.Unset, kittycad.models.path_segment.line, kittycad.models.path_segment.arc, kittycad.models.path_segment.bezier], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Extend a path by adding a new segment which starts at the path\'s "pen". If no "pen" location has been set before (via `MovePen`), then the pen is at the origin.', 'to_dict': <function extend_path.to_dict>, 'from_dict': <classmethod(<function extend_path.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function extend_path.__getitem__>, '__setitem__': <function extend_path.__setitem__>, '__delitem__': <function extend_path.__delitem__>, '__contains__': <function extend_path.__contains__>, '__dict__': <attribute '__dict__' of 'extend_path' objects>, '__weakref__': <attribute '__weakref__' of 'extend_path' objects>, '__attrs_attrs__': (Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='segment', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.path_segment.line, kittycad.models.path_segment.arc, kittycad.models.path_segment.bezier], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='segment'), Attribute(name='type', default='extend_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function extend_path.__repr__>, '__eq__': <function extend_path.__eq__>, '__ne__': <function extend_path.__ne__>, '__lt__': <function extend_path.__lt__>, '__le__': <function extend_path.__le__>, '__gt__': <function extend_path.__gt__>, '__ge__': <function extend_path.__ge__>, '__hash__': None, '__init__': <function extend_path.__init__>, '__match_args__': ('path', 'segment', 'type')})

extend_path.__init__(path=<kittycad.types.Unset object>, segment=<kittycad.types.Unset object>, type='extend_path')

__match_args__ (kittycad.models.modeling_cmd.extend_path attribute)

additional_keys (kittycad.models.modeling_cmd.extend_path property)

additional_properties (kittycad.models.modeling_cmd.extend_path attribute)

from_dict() (kittycad.models.modeling_cmd.extend_path class method)

extrude(cap=False, distance=<kittycad.types.Unset object>, target=<kittycad.types.Unset object>, type='extrude')

(cap=False, distance=<kittycad.types.Unset object>, target=<kittycad.types.Unset object>, type='extrude')

__annotations__ (kittycad.models.modeling_cmd.extrude attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'cap': typing.Union[kittycad.types.Unset, bool], 'distance': typing.Union[kittycad.types.Unset, float], 'target': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.extrude attribute)

(Attribute(name='cap', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cap'), Attribute(name='distance', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='distance'), Attribute(name='target', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='target'), Attribute(name='type', default='extrude', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'cap': typing.Union[kittycad.types.Unset, bool], 'distance': typing.Union[kittycad.types.Unset, float], 'target': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Extrude a 2D solid.', 'to_dict': <function extrude.to_dict>, 'from_dict': <classmethod(<function extrude.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function extrude.__getitem__>, '__setitem__': <function extrude.__setitem__>, '__delitem__': <function extrude.__delitem__>, '__contains__': <function extrude.__contains__>, '__dict__': <attribute '__dict__' of 'extrude' objects>, '__weakref__': <attribute '__weakref__' of 'extrude' objects>, '__attrs_attrs__': (Attribute(name='cap', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cap'), Attribute(name='distance', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='distance'), Attribute(name='target', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='target'), Attribute(name='type', default='extrude', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function extrude.__repr__>, '__eq__': <function extrude.__eq__>, '__ne__': <function extrude.__ne__>, '__lt__': <function extrude.__lt__>, '__le__': <function extrude.__le__>, '__gt__': <function extrude.__gt__>, '__ge__': <function extrude.__ge__>, '__hash__': None, '__init__': <function extrude.__init__>, '__match_args__': ('cap', 'distance', 'target', 'type')})

extrude.__init__(cap=False, distance=<kittycad.types.Unset object>, target=<kittycad.types.Unset object>, type='extrude')

additional_properties (kittycad.models.modeling_cmd.extrude attribute)

get_entity_type(entity_id=<kittycad.types.Unset object>, type='get_entity_type')

(entity_id=<kittycad.types.Unset object>, type='get_entity_type')

__annotations__ (kittycad.models.modeling_cmd.get_entity_type attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.get_entity_type attribute)

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='get_entity_type', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.get_entity_type method)

__delitem__() (kittycad.models.modeling_cmd.get_entity_type method)

__dict__ (kittycad.models.modeling_cmd.get_entity_type attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'What type of entity is this?', 'to_dict': <function get_entity_type.to_dict>, 'from_dict': <classmethod(<function get_entity_type.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function get_entity_type.__getitem__>, '__setitem__': <function get_entity_type.__setitem__>, '__delitem__': <function get_entity_type.__delitem__>, '__contains__': <function get_entity_type.__contains__>, '__dict__': <attribute '__dict__' of 'get_entity_type' objects>, '__weakref__': <attribute '__weakref__' of 'get_entity_type' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='get_entity_type', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function get_entity_type.__repr__>, '__eq__': <function get_entity_type.__eq__>, '__ne__': <function get_entity_type.__ne__>, '__lt__': <function get_entity_type.__lt__>, '__le__': <function get_entity_type.__le__>, '__gt__': <function get_entity_type.__gt__>, '__ge__': <function get_entity_type.__ge__>, '__hash__': None, '__init__': <function get_entity_type.__init__>, '__match_args__': ('entity_id', 'type')})

__getitem__() (kittycad.models.modeling_cmd.get_entity_type method)

__hash__ (kittycad.models.modeling_cmd.get_entity_type attribute)

__init__() (kittycad.models.modeling_cmd.get_entity_type method)

__match_args__ (kittycad.models.modeling_cmd.get_entity_type attribute)

__module__ (kittycad.models.modeling_cmd.get_entity_type attribute)

__repr__() (kittycad.models.modeling_cmd.get_entity_type method)

__setitem__() (kittycad.models.modeling_cmd.get_entity_type method)

additional_keys (kittycad.models.modeling_cmd.get_entity_type property)

additional_properties (kittycad.models.modeling_cmd.get_entity_type attribute)

entity_id (kittycad.models.modeling_cmd.get_entity_type attribute)

from_dict() (kittycad.models.modeling_cmd.get_entity_type class method)

(entities=<kittycad.types.Unset object>, type='highlight_set_entities')

__annotations__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'entities': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

(Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='highlight_set_entities', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__delitem__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__dict__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entities': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Changes the current highlighted entity to these entities.', 'to_dict': <function highlight_set_entities.to_dict>, 'from_dict': <classmethod(<function highlight_set_entities.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function highlight_set_entities.__getitem__>, '__setitem__': <function highlight_set_entities.__setitem__>, '__delitem__': <function highlight_set_entities.__delitem__>, '__contains__': <function highlight_set_entities.__contains__>, '__dict__': <attribute '__dict__' of 'highlight_set_entities' objects>, '__weakref__': <attribute '__weakref__' of 'highlight_set_entities' objects>, '__attrs_attrs__': (Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='highlight_set_entities', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function highlight_set_entities.__repr__>, '__eq__': <function highlight_set_entities.__eq__>, '__ne__': <function highlight_set_entities.__ne__>, '__lt__': <function highlight_set_entities.__lt__>, '__le__': <function highlight_set_entities.__le__>, '__gt__': <function highlight_set_entities.__gt__>, '__ge__': <function highlight_set_entities.__ge__>, '__hash__': None, '__init__': <function highlight_set_entities.__init__>, '__match_args__': ('entities', 'type')})

__eq__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__ge__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__getitem__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__gt__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__hash__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

__init__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__le__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__lt__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__match_args__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

__module__ (kittycad.models.modeling_cmd.highlight_set_entities attribute)

__ne__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__repr__() (kittycad.models.modeling_cmd.highlight_set_entities method)

__setitem__() (kittycad.models.modeling_cmd.highlight_set_entities method)

additional_keys (kittycad.models.modeling_cmd.highlight_set_entities property)

entities (kittycad.models.modeling_cmd.highlight_set_entities attribute)

from_dict() (kittycad.models.modeling_cmd.highlight_set_entities class method)

to_dict() (kittycad.models.modeling_cmd.highlight_set_entities method)

type (kittycad.models.modeling_cmd.highlight_set_entities attribute)

highlight_set_entity(selected_at_window=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

(selected_at_window=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

Changes the current highlighted entity to whichever one is at the given window coordinate. If there's no entity at this location, clears the highlight.

Changes the current highlighted entity to whichever one is at the given window coordinate. If there’s no entity at this location, clears the highlight.

__annotations__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'selected_at_window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

(Attribute(name='selected_at_window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selected_at_window'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='highlight_set_entity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__delitem__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__dict__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'selected_at_window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "Changes the current highlighted entity to whichever one is at the given window coordinate. If there's no entity at this location, clears the highlight.", 'to_dict': <function highlight_set_entity.to_dict>, 'from_dict': <classmethod(<function highlight_set_entity.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function highlight_set_entity.__getitem__>, '__setitem__': <function highlight_set_entity.__setitem__>, '__delitem__': <function highlight_set_entity.__delitem__>, '__contains__': <function highlight_set_entity.__contains__>, '__dict__': <attribute '__dict__' of 'highlight_set_entity' objects>, '__weakref__': <attribute '__weakref__' of 'highlight_set_entity' objects>, '__attrs_attrs__': (Attribute(name='selected_at_window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selected_at_window'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='highlight_set_entity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function highlight_set_entity.__repr__>, '__eq__': <function highlight_set_entity.__eq__>, '__ne__': <function highlight_set_entity.__ne__>, '__lt__': <function highlight_set_entity.__lt__>, '__le__': <function highlight_set_entity.__le__>, '__gt__': <function highlight_set_entity.__gt__>, '__ge__': <function highlight_set_entity.__ge__>, '__hash__': None, '__init__': <function highlight_set_entity.__init__>, '__match_args__': ('selected_at_window', 'sequence', 'type')})

__eq__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__ge__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__getitem__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__gt__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__hash__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

__init__() (kittycad.models.modeling_cmd.highlight_set_entity method)

highlight_set_entity.__init__(selected_at_window=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

__le__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__lt__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__match_args__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

__module__ (kittycad.models.modeling_cmd.highlight_set_entity attribute)

__ne__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__repr__() (kittycad.models.modeling_cmd.highlight_set_entity method)

__setitem__() (kittycad.models.modeling_cmd.highlight_set_entity method)

additional_keys (kittycad.models.modeling_cmd.highlight_set_entity property)

from_dict() (kittycad.models.modeling_cmd.highlight_set_entity class method)

selected_at_window (kittycad.models.modeling_cmd.highlight_set_entity attribute)

sequence (kittycad.models.modeling_cmd.highlight_set_entity attribute)

to_dict() (kittycad.models.modeling_cmd.highlight_set_entity method)

type (kittycad.models.modeling_cmd.highlight_set_entity attribute)

move_path_pen(path=<kittycad.types.Unset object>, to=<kittycad.types.Unset object>, type='move_path_pen')

(path=<kittycad.types.Unset object>, to=<kittycad.types.Unset object>, type='move_path_pen')

__annotations__ (kittycad.models.modeling_cmd.move_path_pen attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'path': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'to': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.move_path_pen attribute)

(Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='to', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='to'), Attribute(name='type', default='move_path_pen', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.move_path_pen method)

__delitem__() (kittycad.models.modeling_cmd.move_path_pen method)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'path': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'to': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Move the path\'s "pen".', 'to_dict': <function move_path_pen.to_dict>, 'from_dict': <classmethod(<function move_path_pen.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function move_path_pen.__getitem__>, '__setitem__': <function move_path_pen.__setitem__>, '__delitem__': <function move_path_pen.__delitem__>, '__contains__': <function move_path_pen.__contains__>, '__dict__': <attribute '__dict__' of 'move_path_pen' objects>, '__weakref__': <attribute '__weakref__' of 'move_path_pen' objects>, '__attrs_attrs__': (Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='to', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='to'), Attribute(name='type', default='move_path_pen', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function move_path_pen.__repr__>, '__eq__': <function move_path_pen.__eq__>, '__ne__': <function move_path_pen.__ne__>, '__lt__': <function move_path_pen.__lt__>, '__le__': <function move_path_pen.__le__>, '__gt__': <function move_path_pen.__gt__>, '__ge__': <function move_path_pen.__ge__>, '__hash__': None, '__init__': <function move_path_pen.__init__>, '__match_args__': ('path', 'to', 'type')})

__getitem__() (kittycad.models.modeling_cmd.move_path_pen method)

move_path_pen.__init__(path=<kittycad.types.Unset object>, to=<kittycad.types.Unset object>, type='move_path_pen')

__match_args__ (kittycad.models.modeling_cmd.move_path_pen attribute)

__module__ (kittycad.models.modeling_cmd.move_path_pen attribute)

__setitem__() (kittycad.models.modeling_cmd.move_path_pen method)

additional_keys (kittycad.models.modeling_cmd.move_path_pen property)

additional_properties (kittycad.models.modeling_cmd.move_path_pen attribute)

from_dict() (kittycad.models.modeling_cmd.move_path_pen class method)

new_annotation(annotation_type=<kittycad.types.Unset object>, clobber=False, options=<kittycad.types.Unset object>, type='new_annotation')

(annotation_type=<kittycad.types.Unset object>, clobber=False, options=<kittycad.types.Unset object>, type='new_annotation')

__annotations__ (kittycad.models.modeling_cmd.new_annotation attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'annotation_type': typing.Union[kittycad.types.Unset, kittycad.models.annotation_type.AnnotationType], 'clobber': typing.Union[kittycad.types.Unset, bool], 'options': typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.new_annotation attribute)

(Attribute(name='annotation_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_type.AnnotationType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='annotation_type'), Attribute(name='clobber', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='clobber'), Attribute(name='options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='options'), Attribute(name='type', default='new_annotation', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.new_annotation method)

__delitem__() (kittycad.models.modeling_cmd.new_annotation method)

__dict__ (kittycad.models.modeling_cmd.new_annotation attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'annotation_type': typing.Union[kittycad.types.Unset, kittycad.models.annotation_type.AnnotationType], 'clobber': typing.Union[kittycad.types.Unset, bool], 'options': typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Create a new annotation', 'to_dict': <function new_annotation.to_dict>, 'from_dict': <classmethod(<function new_annotation.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function new_annotation.__getitem__>, '__setitem__': <function new_annotation.__setitem__>, '__delitem__': <function new_annotation.__delitem__>, '__contains__': <function new_annotation.__contains__>, '__dict__': <attribute '__dict__' of 'new_annotation' objects>, '__weakref__': <attribute '__weakref__' of 'new_annotation' objects>, '__attrs_attrs__': (Attribute(name='annotation_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_type.AnnotationType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='annotation_type'), Attribute(name='clobber', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='clobber'), Attribute(name='options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='options'), Attribute(name='type', default='new_annotation', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function new_annotation.__repr__>, '__eq__': <function new_annotation.__eq__>, '__ne__': <function new_annotation.__ne__>, '__lt__': <function new_annotation.__lt__>, '__le__': <function new_annotation.__le__>, '__gt__': <function new_annotation.__gt__>, '__ge__': <function new_annotation.__ge__>, '__hash__': None, '__init__': <function new_annotation.__init__>, '__match_args__': ('annotation_type', 'clobber', 'options', 'type')})

__getitem__() (kittycad.models.modeling_cmd.new_annotation method)

__hash__ (kittycad.models.modeling_cmd.new_annotation attribute)

new_annotation.__init__(annotation_type=<kittycad.types.Unset object>, clobber=False, options=<kittycad.types.Unset object>, type='new_annotation')

__match_args__ (kittycad.models.modeling_cmd.new_annotation attribute)

__module__ (kittycad.models.modeling_cmd.new_annotation attribute)

__setitem__() (kittycad.models.modeling_cmd.new_annotation method)

additional_keys (kittycad.models.modeling_cmd.new_annotation property)

additional_properties (kittycad.models.modeling_cmd.new_annotation attribute)

annotation_type (kittycad.models.modeling_cmd.new_annotation attribute)

from_dict() (kittycad.models.modeling_cmd.new_annotation class method)

object_visible(hidden=False, object_id=<kittycad.types.Unset object>, type='object_visible')

(hidden=False, object_id=<kittycad.types.Unset object>, type='object_visible')

__annotations__ (kittycad.models.modeling_cmd.object_visible attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'hidden': typing.Union[kittycad.types.Unset, bool], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.object_visible attribute)

(Attribute(name='hidden', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='hidden'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='object_visible', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.object_visible method)

__delitem__() (kittycad.models.modeling_cmd.object_visible method)

__dict__ (kittycad.models.modeling_cmd.object_visible attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'hidden': typing.Union[kittycad.types.Unset, bool], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Hide or show an object', 'to_dict': <function object_visible.to_dict>, 'from_dict': <classmethod(<function object_visible.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function object_visible.__getitem__>, '__setitem__': <function object_visible.__setitem__>, '__delitem__': <function object_visible.__delitem__>, '__contains__': <function object_visible.__contains__>, '__dict__': <attribute '__dict__' of 'object_visible' objects>, '__weakref__': <attribute '__weakref__' of 'object_visible' objects>, '__attrs_attrs__': (Attribute(name='hidden', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='hidden'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='object_visible', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function object_visible.__repr__>, '__eq__': <function object_visible.__eq__>, '__ne__': <function object_visible.__ne__>, '__lt__': <function object_visible.__lt__>, '__le__': <function object_visible.__le__>, '__gt__': <function object_visible.__gt__>, '__ge__': <function object_visible.__ge__>, '__hash__': None, '__init__': <function object_visible.__init__>, '__match_args__': ('hidden', 'object_id', 'type')})

__getitem__() (kittycad.models.modeling_cmd.object_visible method)

__hash__ (kittycad.models.modeling_cmd.object_visible attribute)

object_visible.__init__(hidden=False, object_id=<kittycad.types.Unset object>, type='object_visible')

__match_args__ (kittycad.models.modeling_cmd.object_visible attribute)

__module__ (kittycad.models.modeling_cmd.object_visible attribute)

__setitem__() (kittycad.models.modeling_cmd.object_visible method)

additional_keys (kittycad.models.modeling_cmd.object_visible property)

additional_properties (kittycad.models.modeling_cmd.object_visible attribute)

from_dict() (kittycad.models.modeling_cmd.object_visible class method)

object_id (kittycad.models.modeling_cmd.object_visible attribute)

select_add(entities=<kittycad.types.Unset object>, type='select_add')

__annotations__ (kittycad.models.modeling_cmd.select_add attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.select_add attribute)

(Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_add', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entities': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Adds one or more entities (by UUID) to the selection.', 'to_dict': <function select_add.to_dict>, 'from_dict': <classmethod(<function select_add.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_add.__getitem__>, '__setitem__': <function select_add.__setitem__>, '__delitem__': <function select_add.__delitem__>, '__contains__': <function select_add.__contains__>, '__dict__': <attribute '__dict__' of 'select_add' objects>, '__weakref__': <attribute '__weakref__' of 'select_add' objects>, '__attrs_attrs__': (Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_add', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_add.__repr__>, '__eq__': <function select_add.__eq__>, '__ne__': <function select_add.__ne__>, '__lt__': <function select_add.__lt__>, '__le__': <function select_add.__le__>, '__gt__': <function select_add.__gt__>, '__ge__': <function select_add.__ge__>, '__hash__': None, '__init__': <function select_add.__init__>, '__match_args__': ('entities', 'type')})

select_add.__init__(entities=<kittycad.types.Unset object>, type='select_add')

__match_args__ (kittycad.models.modeling_cmd.select_add attribute)

additional_keys (kittycad.models.modeling_cmd.select_add property)

additional_properties (kittycad.models.modeling_cmd.select_add attribute)

from_dict() (kittycad.models.modeling_cmd.select_add class method)

__annotations__ (kittycad.models.modeling_cmd.select_clear attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.select_clear attribute)

(Attribute(name='type', default='select_clear', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.select_clear method)

__delitem__() (kittycad.models.modeling_cmd.select_clear method)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Clear the selection', 'to_dict': <function select_clear.to_dict>, 'from_dict': <classmethod(<function select_clear.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_clear.__getitem__>, '__setitem__': <function select_clear.__setitem__>, '__delitem__': <function select_clear.__delitem__>, '__contains__': <function select_clear.__contains__>, '__dict__': <attribute '__dict__' of 'select_clear' objects>, '__weakref__': <attribute '__weakref__' of 'select_clear' objects>, '__attrs_attrs__': (Attribute(name='type', default='select_clear', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_clear.__repr__>, '__eq__': <function select_clear.__eq__>, '__ne__': <function select_clear.__ne__>, '__lt__': <function select_clear.__lt__>, '__le__': <function select_clear.__le__>, '__gt__': <function select_clear.__gt__>, '__ge__': <function select_clear.__ge__>, '__hash__': None, '__init__': <function select_clear.__init__>, '__match_args__': ('type',)})

__getitem__() (kittycad.models.modeling_cmd.select_clear method)

__match_args__ (kittycad.models.modeling_cmd.select_clear attribute)

__module__ (kittycad.models.modeling_cmd.select_clear attribute)

__setitem__() (kittycad.models.modeling_cmd.select_clear method)

additional_keys (kittycad.models.modeling_cmd.select_clear property)

additional_properties (kittycad.models.modeling_cmd.select_clear attribute)

from_dict() (kittycad.models.modeling_cmd.select_clear class method)

__annotations__ (kittycad.models.modeling_cmd.select_get attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.select_get attribute)

(Attribute(name='type', default='select_get', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Find all IDs of selected entities', 'to_dict': <function select_get.to_dict>, 'from_dict': <classmethod(<function select_get.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_get.__getitem__>, '__setitem__': <function select_get.__setitem__>, '__delitem__': <function select_get.__delitem__>, '__contains__': <function select_get.__contains__>, '__dict__': <attribute '__dict__' of 'select_get' objects>, '__weakref__': <attribute '__weakref__' of 'select_get' objects>, '__attrs_attrs__': (Attribute(name='type', default='select_get', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_get.__repr__>, '__eq__': <function select_get.__eq__>, '__ne__': <function select_get.__ne__>, '__lt__': <function select_get.__lt__>, '__le__': <function select_get.__le__>, '__gt__': <function select_get.__gt__>, '__ge__': <function select_get.__ge__>, '__hash__': None, '__init__': <function select_get.__init__>, '__match_args__': ('type',)})

__match_args__ (kittycad.models.modeling_cmd.select_get attribute)

additional_keys (kittycad.models.modeling_cmd.select_get property)

additional_properties (kittycad.models.modeling_cmd.select_get attribute)

from_dict() (kittycad.models.modeling_cmd.select_get class method)

select_remove(entities=<kittycad.types.Unset object>, type='select_remove')

__annotations__ (kittycad.models.modeling_cmd.select_remove attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.select_remove attribute)

(Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_remove', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.select_remove method)

__delitem__() (kittycad.models.modeling_cmd.select_remove method)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entities': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Removes one or more entities (by UUID) from the selection.', 'to_dict': <function select_remove.to_dict>, 'from_dict': <classmethod(<function select_remove.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_remove.__getitem__>, '__setitem__': <function select_remove.__setitem__>, '__delitem__': <function select_remove.__delitem__>, '__contains__': <function select_remove.__contains__>, '__dict__': <attribute '__dict__' of 'select_remove' objects>, '__weakref__': <attribute '__weakref__' of 'select_remove' objects>, '__attrs_attrs__': (Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_remove', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_remove.__repr__>, '__eq__': <function select_remove.__eq__>, '__ne__': <function select_remove.__ne__>, '__lt__': <function select_remove.__lt__>, '__le__': <function select_remove.__le__>, '__gt__': <function select_remove.__gt__>, '__ge__': <function select_remove.__ge__>, '__hash__': None, '__init__': <function select_remove.__init__>, '__match_args__': ('entities', 'type')})

__getitem__() (kittycad.models.modeling_cmd.select_remove method)

__match_args__ (kittycad.models.modeling_cmd.select_remove attribute)

__module__ (kittycad.models.modeling_cmd.select_remove attribute)

__setitem__() (kittycad.models.modeling_cmd.select_remove method)

additional_keys (kittycad.models.modeling_cmd.select_remove property)

additional_properties (kittycad.models.modeling_cmd.select_remove attribute)

from_dict() (kittycad.models.modeling_cmd.select_remove class method)

select_replace(entities=<kittycad.types.Unset object>, type='select_replace')

Replaces the current selection with these new entities (by UUID). Equivalent to doing SelectClear then SelectAdd.

__annotations__ (kittycad.models.modeling_cmd.select_replace attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.select_replace attribute)

(Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_replace', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.select_replace method)

__delitem__() (kittycad.models.modeling_cmd.select_replace method)

__dict__ (kittycad.models.modeling_cmd.select_replace attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'entities': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Replaces the current selection with these new entities (by UUID). Equivalent to doing SelectClear then SelectAdd.', 'to_dict': <function select_replace.to_dict>, 'from_dict': <classmethod(<function select_replace.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_replace.__getitem__>, '__setitem__': <function select_replace.__setitem__>, '__delitem__': <function select_replace.__delitem__>, '__contains__': <function select_replace.__contains__>, '__dict__': <attribute '__dict__' of 'select_replace' objects>, '__weakref__': <attribute '__weakref__' of 'select_replace' objects>, '__attrs_attrs__': (Attribute(name='entities', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entities'), Attribute(name='type', default='select_replace', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_replace.__repr__>, '__eq__': <function select_replace.__eq__>, '__ne__': <function select_replace.__ne__>, '__lt__': <function select_replace.__lt__>, '__le__': <function select_replace.__le__>, '__gt__': <function select_replace.__gt__>, '__ge__': <function select_replace.__ge__>, '__hash__': None, '__init__': <function select_replace.__init__>, '__match_args__': ('entities', 'type')})

__getitem__() (kittycad.models.modeling_cmd.select_replace method)

__hash__ (kittycad.models.modeling_cmd.select_replace attribute)

__match_args__ (kittycad.models.modeling_cmd.select_replace attribute)

__module__ (kittycad.models.modeling_cmd.select_replace attribute)

__setitem__() (kittycad.models.modeling_cmd.select_replace method)

additional_keys (kittycad.models.modeling_cmd.select_replace property)

additional_properties (kittycad.models.modeling_cmd.select_replace attribute)

entities (kittycad.models.modeling_cmd.select_replace attribute)

from_dict() (kittycad.models.modeling_cmd.select_replace class method)

select_with_point(selected_at_window=<kittycad.types.Unset object>, selection_type=<kittycad.types.Unset object>, type='select_with_point')

(selected_at_window=<kittycad.types.Unset object>, selection_type=<kittycad.types.Unset object>, type='select_with_point')

Modifies the selection by simulating a “mouse click” at the given x,y window coordinate Returns ID of whatever was selected.

__annotations__ (kittycad.models.modeling_cmd.select_with_point attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'selected_at_window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'selection_type': typing.Union[kittycad.types.Unset, kittycad.models.scene_selection_type.SceneSelectionType], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.select_with_point attribute)

(Attribute(name='selected_at_window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selected_at_window'), Attribute(name='selection_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.scene_selection_type.SceneSelectionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selection_type'), Attribute(name='type', default='select_with_point', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.select_with_point method)

__delitem__() (kittycad.models.modeling_cmd.select_with_point method)

__dict__ (kittycad.models.modeling_cmd.select_with_point attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'selected_at_window': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'selection_type': typing.Union[kittycad.types.Unset, kittycad.models.scene_selection_type.SceneSelectionType], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Modifies the selection by simulating a "mouse click" at the given x,y window coordinate Returns ID of whatever was selected.', 'to_dict': <function select_with_point.to_dict>, 'from_dict': <classmethod(<function select_with_point.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_with_point.__getitem__>, '__setitem__': <function select_with_point.__setitem__>, '__delitem__': <function select_with_point.__delitem__>, '__contains__': <function select_with_point.__contains__>, '__dict__': <attribute '__dict__' of 'select_with_point' objects>, '__weakref__': <attribute '__weakref__' of 'select_with_point' objects>, '__attrs_attrs__': (Attribute(name='selected_at_window', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selected_at_window'), Attribute(name='selection_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.scene_selection_type.SceneSelectionType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='selection_type'), Attribute(name='type', default='select_with_point', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_with_point.__repr__>, '__eq__': <function select_with_point.__eq__>, '__ne__': <function select_with_point.__ne__>, '__lt__': <function select_with_point.__lt__>, '__le__': <function select_with_point.__le__>, '__gt__': <function select_with_point.__gt__>, '__ge__': <function select_with_point.__ge__>, '__hash__': None, '__init__': <function select_with_point.__init__>, '__match_args__': ('selected_at_window', 'selection_type', 'type')})

__eq__() (kittycad.models.modeling_cmd.select_with_point method)

__ge__() (kittycad.models.modeling_cmd.select_with_point method)

__getitem__() (kittycad.models.modeling_cmd.select_with_point method)

__gt__() (kittycad.models.modeling_cmd.select_with_point method)

__hash__ (kittycad.models.modeling_cmd.select_with_point attribute)

__init__() (kittycad.models.modeling_cmd.select_with_point method)

select_with_point.__init__(selected_at_window=<kittycad.types.Unset object>, selection_type=<kittycad.types.Unset object>, type='select_with_point')

__le__() (kittycad.models.modeling_cmd.select_with_point method)

__lt__() (kittycad.models.modeling_cmd.select_with_point method)

__match_args__ (kittycad.models.modeling_cmd.select_with_point attribute)

__module__ (kittycad.models.modeling_cmd.select_with_point attribute)

__ne__() (kittycad.models.modeling_cmd.select_with_point method)

__repr__() (kittycad.models.modeling_cmd.select_with_point method)

__setitem__() (kittycad.models.modeling_cmd.select_with_point method)

additional_keys (kittycad.models.modeling_cmd.select_with_point property)

additional_properties (kittycad.models.modeling_cmd.select_with_point attribute)

from_dict() (kittycad.models.modeling_cmd.select_with_point class method)

selected_at_window (kittycad.models.modeling_cmd.select_with_point attribute)

selection_type (kittycad.models.modeling_cmd.select_with_point attribute)

to_dict() (kittycad.models.modeling_cmd.select_with_point method)

solid3d_get_all_edge_faces (class in kittycad.models.modeling_cmd)

solid3d_get_all_edge_faces(edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_edge_faces')

(edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_edge_faces')

{'additional_properties': typing.Dict[str, typing.Any], 'edge_id': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

(Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_all_edge_faces', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__delitem__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__dict__ (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'edge_id': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gets all faces which use the given edge.', 'to_dict': <function solid3d_get_all_edge_faces.to_dict>, 'from_dict': <classmethod(<function solid3d_get_all_edge_faces.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_all_edge_faces.__getitem__>, '__setitem__': <function solid3d_get_all_edge_faces.__setitem__>, '__delitem__': <function solid3d_get_all_edge_faces.__delitem__>, '__contains__': <function solid3d_get_all_edge_faces.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_all_edge_faces' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_all_edge_faces' objects>, '__attrs_attrs__': (Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_all_edge_faces', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_all_edge_faces.__repr__>, '__eq__': <function solid3d_get_all_edge_faces.__eq__>, '__ne__': <function solid3d_get_all_edge_faces.__ne__>, '__lt__': <function solid3d_get_all_edge_faces.__lt__>, '__le__': <function solid3d_get_all_edge_faces.__le__>, '__gt__': <function solid3d_get_all_edge_faces.__gt__>, '__ge__': <function solid3d_get_all_edge_faces.__ge__>, '__hash__': None, '__init__': <function solid3d_get_all_edge_faces.__init__>, '__match_args__': ('edge_id', 'object_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__ge__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__getitem__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__gt__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__hash__ (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

__init__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

solid3d_get_all_edge_faces.__init__(edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_edge_faces')

__le__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__lt__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__module__ (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

__ne__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__repr__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

__setitem__() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

edge_id (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

from_dict() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces class method)

object_id (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

to_dict() (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces method)

type (kittycad.models.modeling_cmd.solid3d_get_all_edge_faces attribute)

solid3d_get_all_opposite_edges (class in kittycad.models.modeling_cmd)

solid3d_get_all_opposite_edges(along_vector=<kittycad.types.Unset object>, edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_opposite_edges')

(along_vector=<kittycad.types.Unset object>, edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_opposite_edges')

Method generated by attrs for class solid3d_get_all_opposite_edges.

{'additional_properties': typing.Dict[str, typing.Any], 'along_vector': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'edge_id': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

(Attribute(name='along_vector', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='along_vector'), Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_all_opposite_edges', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'along_vector': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'edge_id': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gets all edges which are opposite the given edge, across all possible faces.', 'to_dict': <function solid3d_get_all_opposite_edges.to_dict>, 'from_dict': <classmethod(<function solid3d_get_all_opposite_edges.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_all_opposite_edges.__getitem__>, '__setitem__': <function solid3d_get_all_opposite_edges.__setitem__>, '__delitem__': <function solid3d_get_all_opposite_edges.__delitem__>, '__contains__': <function solid3d_get_all_opposite_edges.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_all_opposite_edges' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_all_opposite_edges' objects>, '__attrs_attrs__': (Attribute(name='along_vector', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='along_vector'), Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_all_opposite_edges', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_all_opposite_edges.__repr__>, '__eq__': <function solid3d_get_all_opposite_edges.__eq__>, '__ne__': <function solid3d_get_all_opposite_edges.__ne__>, '__lt__': <function solid3d_get_all_opposite_edges.__lt__>, '__le__': <function solid3d_get_all_opposite_edges.__le__>, '__gt__': <function solid3d_get_all_opposite_edges.__gt__>, '__ge__': <function solid3d_get_all_opposite_edges.__ge__>, '__hash__': None, '__init__': <function solid3d_get_all_opposite_edges.__init__>, '__match_args__': ('along_vector', 'edge_id', 'object_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__ge__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__gt__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__hash__ (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges attribute)

__init__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

solid3d_get_all_opposite_edges.__init__(along_vector=<kittycad.types.Unset object>, edge_id=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_all_opposite_edges')

__le__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__lt__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__ne__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

__repr__() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

edge_id (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges attribute)

from_dict() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges class method)

to_dict() (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges method)

type (kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges attribute)

solid3d_get_next_adjacent_edge (class in kittycad.models.modeling_cmd)

solid3d_get_next_adjacent_edge(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_next_adjacent_edge')

(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_next_adjacent_edge')

Method generated by attrs for class solid3d_get_next_adjacent_edge.

{'additional_properties': typing.Dict[str, typing.Any], 'edge_id': typing.Union[kittycad.types.Unset, str], 'face_uuid': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

(Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_next_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'edge_id': typing.Union[kittycad.types.Unset, str], 'face_uuid': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gets the next adjacent edge for the given edge, along the given face.', 'to_dict': <function solid3d_get_next_adjacent_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_next_adjacent_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_next_adjacent_edge.__getitem__>, '__setitem__': <function solid3d_get_next_adjacent_edge.__setitem__>, '__delitem__': <function solid3d_get_next_adjacent_edge.__delitem__>, '__contains__': <function solid3d_get_next_adjacent_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_next_adjacent_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_next_adjacent_edge' objects>, '__attrs_attrs__': (Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_next_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_next_adjacent_edge.__repr__>, '__eq__': <function solid3d_get_next_adjacent_edge.__eq__>, '__ne__': <function solid3d_get_next_adjacent_edge.__ne__>, '__lt__': <function solid3d_get_next_adjacent_edge.__lt__>, '__le__': <function solid3d_get_next_adjacent_edge.__le__>, '__gt__': <function solid3d_get_next_adjacent_edge.__gt__>, '__ge__': <function solid3d_get_next_adjacent_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_next_adjacent_edge.__init__>, '__match_args__': ('edge_id', 'face_uuid', 'object_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__ge__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__gt__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__hash__ (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge attribute)

__init__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

solid3d_get_next_adjacent_edge.__init__(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_next_adjacent_edge')

__le__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__lt__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__ne__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

__repr__() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

edge_id (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge attribute)

from_dict() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge class method)

to_dict() (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge method)

type (kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge attribute)

solid3d_get_opposite_edge (class in kittycad.models.modeling_cmd)

solid3d_get_opposite_edge(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_opposite_edge')

(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_opposite_edge')

(Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_opposite_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__delitem__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__dict__ (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'edge_id': typing.Union[kittycad.types.Unset, str], 'face_uuid': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gets the edge opposite the given edge, along the given face.', 'to_dict': <function solid3d_get_opposite_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_opposite_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_opposite_edge.__getitem__>, '__setitem__': <function solid3d_get_opposite_edge.__setitem__>, '__delitem__': <function solid3d_get_opposite_edge.__delitem__>, '__contains__': <function solid3d_get_opposite_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_opposite_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_opposite_edge' objects>, '__attrs_attrs__': (Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_opposite_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_opposite_edge.__repr__>, '__eq__': <function solid3d_get_opposite_edge.__eq__>, '__ne__': <function solid3d_get_opposite_edge.__ne__>, '__lt__': <function solid3d_get_opposite_edge.__lt__>, '__le__': <function solid3d_get_opposite_edge.__le__>, '__gt__': <function solid3d_get_opposite_edge.__gt__>, '__ge__': <function solid3d_get_opposite_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_opposite_edge.__init__>, '__match_args__': ('edge_id', 'face_uuid', 'object_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__ge__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__getitem__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__gt__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__hash__ (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

__init__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

solid3d_get_opposite_edge.__init__(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_opposite_edge')

__le__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__lt__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__module__ (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

__ne__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__repr__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

__setitem__() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

edge_id (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

face_uuid (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

from_dict() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge class method)

object_id (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

to_dict() (kittycad.models.modeling_cmd.solid3d_get_opposite_edge method)

type (kittycad.models.modeling_cmd.solid3d_get_opposite_edge attribute)

solid3d_get_prev_adjacent_edge (class in kittycad.models.modeling_cmd)

solid3d_get_prev_adjacent_edge(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_prev_adjacent_edge')

(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_prev_adjacent_edge')

Method generated by attrs for class solid3d_get_prev_adjacent_edge.

(Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_prev_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'edge_id': typing.Union[kittycad.types.Unset, str], 'face_uuid': typing.Union[kittycad.types.Unset, str], 'object_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Gets the previous adjacent edge for the given edge, along the given face.', 'to_dict': <function solid3d_get_prev_adjacent_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_prev_adjacent_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_prev_adjacent_edge.__getitem__>, '__setitem__': <function solid3d_get_prev_adjacent_edge.__setitem__>, '__delitem__': <function solid3d_get_prev_adjacent_edge.__delitem__>, '__contains__': <function solid3d_get_prev_adjacent_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_prev_adjacent_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_prev_adjacent_edge' objects>, '__attrs_attrs__': (Attribute(name='edge_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge_id'), Attribute(name='face_uuid', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='face_uuid'), Attribute(name='object_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='object_id'), Attribute(name='type', default='solid3d_get_prev_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_prev_adjacent_edge.__repr__>, '__eq__': <function solid3d_get_prev_adjacent_edge.__eq__>, '__ne__': <function solid3d_get_prev_adjacent_edge.__ne__>, '__lt__': <function solid3d_get_prev_adjacent_edge.__lt__>, '__le__': <function solid3d_get_prev_adjacent_edge.__le__>, '__gt__': <function solid3d_get_prev_adjacent_edge.__gt__>, '__ge__': <function solid3d_get_prev_adjacent_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_prev_adjacent_edge.__init__>, '__match_args__': ('edge_id', 'face_uuid', 'object_id', 'type')})

__eq__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__ge__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__gt__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__hash__ (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge attribute)

__init__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

solid3d_get_prev_adjacent_edge.__init__(edge_id=<kittycad.types.Unset object>, face_uuid=<kittycad.types.Unset object>, object_id=<kittycad.types.Unset object>, type='solid3d_get_prev_adjacent_edge')

__le__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__lt__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__ne__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

__repr__() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

edge_id (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge attribute)

from_dict() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge class method)

to_dict() (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge method)

type (kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge attribute)

__annotations__ (kittycad.models.modeling_cmd.start_path attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd.start_path attribute)

(Attribute(name='type', default='start_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Start a path.', 'to_dict': <function start_path.to_dict>, 'from_dict': <classmethod(<function start_path.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function start_path.__getitem__>, '__setitem__': <function start_path.__setitem__>, '__delitem__': <function start_path.__delitem__>, '__contains__': <function start_path.__contains__>, '__dict__': <attribute '__dict__' of 'start_path' objects>, '__weakref__': <attribute '__weakref__' of 'start_path' objects>, '__attrs_attrs__': (Attribute(name='type', default='start_path', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function start_path.__repr__>, '__eq__': <function start_path.__eq__>, '__ne__': <function start_path.__ne__>, '__lt__': <function start_path.__lt__>, '__le__': <function start_path.__le__>, '__gt__': <function start_path.__gt__>, '__ge__': <function start_path.__ge__>, '__hash__': None, '__init__': <function start_path.__init__>, '__match_args__': ('type',)})

__match_args__ (kittycad.models.modeling_cmd.start_path attribute)

additional_keys (kittycad.models.modeling_cmd.start_path property)

additional_properties (kittycad.models.modeling_cmd.start_path attribute)

from_dict() (kittycad.models.modeling_cmd.start_path class method)

update_annotation(annotation_id=<kittycad.types.Unset object>, options=<kittycad.types.Unset object>, type='update_annotation')

(annotation_id=<kittycad.types.Unset object>, options=<kittycad.types.Unset object>, type='update_annotation')

__annotations__ (kittycad.models.modeling_cmd.update_annotation attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'annotation_id': typing.Union[kittycad.types.Unset, str], 'options': typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.modeling_cmd.update_annotation attribute)

(Attribute(name='annotation_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='annotation_id'), Attribute(name='options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='options'), Attribute(name='type', default='update_annotation', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd.update_annotation method)

__delitem__() (kittycad.models.modeling_cmd.update_annotation method)

__dict__ (kittycad.models.modeling_cmd.update_annotation attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd', '__annotations__': {'annotation_id': typing.Union[kittycad.types.Unset, str], 'options': typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Update an annotation', 'to_dict': <function update_annotation.to_dict>, 'from_dict': <classmethod(<function update_annotation.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function update_annotation.__getitem__>, '__setitem__': <function update_annotation.__setitem__>, '__delitem__': <function update_annotation.__delitem__>, '__contains__': <function update_annotation.__contains__>, '__dict__': <attribute '__dict__' of 'update_annotation' objects>, '__weakref__': <attribute '__weakref__' of 'update_annotation' objects>, '__attrs_attrs__': (Attribute(name='annotation_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='annotation_id'), Attribute(name='options', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.annotation_options.AnnotationOptions], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='options'), Attribute(name='type', default='update_annotation', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function update_annotation.__repr__>, '__eq__': <function update_annotation.__eq__>, '__ne__': <function update_annotation.__ne__>, '__lt__': <function update_annotation.__lt__>, '__le__': <function update_annotation.__le__>, '__gt__': <function update_annotation.__gt__>, '__ge__': <function update_annotation.__ge__>, '__hash__': None, '__init__': <function update_annotation.__init__>, '__match_args__': ('annotation_id', 'options', 'type')})

__eq__() (kittycad.models.modeling_cmd.update_annotation method)

__ge__() (kittycad.models.modeling_cmd.update_annotation method)

__getitem__() (kittycad.models.modeling_cmd.update_annotation method)

__gt__() (kittycad.models.modeling_cmd.update_annotation method)

__hash__ (kittycad.models.modeling_cmd.update_annotation attribute)

__init__() (kittycad.models.modeling_cmd.update_annotation method)

update_annotation.__init__(annotation_id=<kittycad.types.Unset object>, options=<kittycad.types.Unset object>, type='update_annotation')

__le__() (kittycad.models.modeling_cmd.update_annotation method)

__lt__() (kittycad.models.modeling_cmd.update_annotation method)

__match_args__ (kittycad.models.modeling_cmd.update_annotation attribute)

__module__ (kittycad.models.modeling_cmd.update_annotation attribute)

__ne__() (kittycad.models.modeling_cmd.update_annotation method)

__repr__() (kittycad.models.modeling_cmd.update_annotation method)

__setitem__() (kittycad.models.modeling_cmd.update_annotation method)

additional_keys (kittycad.models.modeling_cmd.update_annotation property)

additional_properties (kittycad.models.modeling_cmd.update_annotation attribute)

annotation_id (kittycad.models.modeling_cmd.update_annotation attribute)

from_dict() (kittycad.models.modeling_cmd.update_annotation class method)

options (kittycad.models.modeling_cmd.update_annotation attribute)

to_dict() (kittycad.models.modeling_cmd.update_annotation method)

__init__([interaction, type, window])

Method generated by attrs for class camera_drag_end.

rtype

TypeVar(OR, bound= camera_drag_end)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.camera_drag_end.__init__>`\ \(\[interaction\, type\, window\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.camera_drag_end.to_dict>`\ \(\)

interaction

type

window

__init__([interaction, sequence, type, window])

Method generated by attrs for class camera_drag_move.

rtype

TypeVar(BA, bound= camera_drag_move)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.camera_drag_move.__init__>`\ \(\[interaction\, sequence\, type\, window\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.camera_drag_move.to_dict>`\ \(\)

sequence

type

window

Method generated by attrs for class camera_drag_start.

rtype

TypeVar(DN, bound= camera_drag_start)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.camera_drag_start.__init__>`\ \(\[interaction\, type\, window\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.camera_drag_start.to_dict>`\ \(\)

__init__([path_id, type])

Method generated by attrs for class close_path.

rtype

TypeVar(RO, bound= close_path)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.close_path.__init__>`\ \(\[path\_id\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.close_path.to_dict>`\ \(\)

path_id

type

rtype

TypeVar(TO, bound= default_camera_disable_sketch_mode)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``TO``, bound= default_camera_disable_sketch_mode)

__init__([animated, distance_to_plane, ...])

rtype

TypeVar(LC, bound= default_camera_enable_sketch_mode)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.default_camera_enable_sketch_mode.__init__>`\ \(\[animated\, distance\_to\_plane\, ...\]\)

:py:class:`~typing.TypeVar`\(``LC``, bound= default_camera_enable_sketch_mode)

animated

distance_to_plane

origin

ortho

type

x_axis

y_axis

__init__([center, type, up, vantage])

Method generated by attrs for class default_camera_look_at.

rtype

TypeVar(CB, bound= default_camera_look_at)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.default_camera_look_at.__init__>`\ \(\[center\, type\, up\, vantage\]\)

:py:class:`~typing.TypeVar`\(``CB``, bound= default_camera_look_at)

center

type

up

vantage

__init__([target, type])

Method generated by attrs for class edit_mode_enter.

rtype

TypeVar(IZ, bound= edit_mode_enter)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.edit_mode_enter.__init__>`\ \(\[target\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.edit_mode_enter.to_dict>`\ \(\)

target

type

Method generated by attrs for class edit_mode_exit.

rtype

TypeVar(WO, bound= edit_mode_exit)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.modeling_cmd.edit_mode_exit.to_dict>`\ \(\)

__init__([entity_id, type])

Method generated by attrs for class entity_get_all_child_uuids.

rtype

TypeVar(KX, bound= entity_get_all_child_uuids)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.entity_get_all_child_uuids.__init__>`\ \(\[entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``KX``, bound= entity_get_all_child_uuids)

entity_id

type

__init__([child_index, entity_id, type])

Method generated by attrs for class entity_get_child_uuid.

rtype

TypeVar(QO, bound= entity_get_child_uuid)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.entity_get_child_uuid.__init__>`\ \(\[child\_index\, entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``QO``, bound= entity_get_child_uuid)

child_index

entity_id

type

Method generated by attrs for class entity_get_num_children.

rtype

TypeVar(NY, bound= entity_get_num_children)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.entity_get_num_children.__init__>`\ \(\[entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``NY``, bound= entity_get_num_children)

Method generated by attrs for class entity_get_parent_id.

rtype

TypeVar(EO, bound= entity_get_parent_id)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.entity_get_parent_id.__init__>`\ \(\[entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``EO``, bound= entity_get_parent_id)

__init__([entity_ids, format, type])

Method generated by attrs for class export.

rtype

TypeVar(ZP, bound= export)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.export.__init__>`\ \(\[entity\_ids\, format\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.export.to_dict>`\ \(\)

entity_ids

format

type

__init__([path, segment, type])

Method generated by attrs for class extend_path.

rtype

TypeVar(MP, bound= extend_path)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.extend_path.__init__>`\ \(\[path\, segment\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.extend_path.to_dict>`\ \(\)

path

segment

type

__init__([cap, distance, target, type])

Method generated by attrs for class extrude.

rtype

TypeVar(WF, bound= extrude)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.extrude.__init__>`\ \(\[cap\, distance\, target\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.extrude.to_dict>`\ \(\)

cap

distance

target

type

Method generated by attrs for class get_entity_type.

rtype

TypeVar(WJ, bound= get_entity_type)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.get_entity_type.__init__>`\ \(\[entity\_id\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.get_entity_type.to_dict>`\ \(\)

__init__([entities, type])

Method generated by attrs for class highlight_set_entities.

rtype

TypeVar(SS, bound= highlight_set_entities)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.highlight_set_entities.__init__>`\ \(\[entities\, type\]\)

:py:class:`~typing.TypeVar`\(``SS``, bound= highlight_set_entities)

entities

type

__init__([selected_at_window, sequence, type])

Method generated by attrs for class highlight_set_entity.

rtype

TypeVar(GU, bound= highlight_set_entity)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.highlight_set_entity.__init__>`\ \(\[selected\_at\_window\, sequence\, type\]\)

:py:class:`~typing.TypeVar`\(``GU``, bound= highlight_set_entity)

selected_at_window

sequence

type

__init__([path, to, type])

Method generated by attrs for class move_path_pen.

rtype

TypeVar(LR, bound= move_path_pen)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.move_path_pen.__init__>`\ \(\[path\, to\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.move_path_pen.to_dict>`\ \(\)

path

to

type

__init__([annotation_type, clobber, ...])

Method generated by attrs for class new_annotation.

rtype

TypeVar(UP, bound= new_annotation)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.new_annotation.__init__>`\ \(\[annotation\_type\, clobber\, ...\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.new_annotation.to_dict>`\ \(\)

annotation_type

clobber

options

type

__init__([hidden, object_id, type])

Method generated by attrs for class object_visible.

rtype

TypeVar(DJ, bound= object_visible)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.object_visible.__init__>`\ \(\[hidden\, object\_id\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.object_visible.to_dict>`\ \(\)

hidden

object_id

type

Method generated by attrs for class select_add.

rtype

TypeVar(QE, bound= select_add)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.select_add.__init__>`\ \(\[entities\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_add.to_dict>`\ \(\)

Method generated by attrs for class select_clear.

rtype

TypeVar(UQ, bound= select_clear)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_clear.to_dict>`\ \(\)

Method generated by attrs for class select_get.

rtype

TypeVar(BV, bound= select_get)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_get.to_dict>`\ \(\)

Method generated by attrs for class select_remove.

rtype

TypeVar(XH, bound= select_remove)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.select_remove.__init__>`\ \(\[entities\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_remove.to_dict>`\ \(\)

Method generated by attrs for class select_replace.

rtype

TypeVar(KT, bound= select_replace)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.select_replace.__init__>`\ \(\[entities\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_replace.to_dict>`\ \(\)

__init__([selected_at_window, ...])

Method generated by attrs for class select_with_point.

rtype

TypeVar(NK, bound= select_with_point)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.select_with_point.__init__>`\ \(\[selected\_at\_window\, ...\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.select_with_point.to_dict>`\ \(\)

selection_type

type

__init__([edge_id, object_id, type])

Method generated by attrs for class solid3d_get_all_edge_faces.

rtype

TypeVar(TR, bound= solid3d_get_all_edge_faces)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.solid3d_get_all_edge_faces.__init__>`\ \(\[edge\_id\, object\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``TR``, bound= solid3d_get_all_edge_faces)

edge_id

object_id

type

__init__([along_vector, edge_id, object_id, ...])

rtype

TypeVar(YD, bound= solid3d_get_all_opposite_edges)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges.__init__>`\ \(\[along\_vector\, edge\_id\, object\_id\, ...\]\)

:py:class:`~typing.TypeVar`\(``YD``, bound= solid3d_get_all_opposite_edges)

along_vector

edge_id

object_id

type

__init__([edge_id, face_uuid, object_id, type])

rtype

TypeVar(VP, bound= solid3d_get_next_adjacent_edge)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge.__init__>`\ \(\[edge\_id\, face\_uuid\, object\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``VP``, bound= solid3d_get_next_adjacent_edge)

edge_id

face_uuid

object_id

type

Method generated by attrs for class solid3d_get_opposite_edge.

rtype

TypeVar(JF, bound= solid3d_get_opposite_edge)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.solid3d_get_opposite_edge.__init__>`\ \(\[edge\_id\, face\_uuid\, object\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``JF``, bound= solid3d_get_opposite_edge)

rtype

TypeVar(EL, bound= solid3d_get_prev_adjacent_edge)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge.__init__>`\ \(\[edge\_id\, face\_uuid\, object\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``EL``, bound= solid3d_get_prev_adjacent_edge)

Method generated by attrs for class start_path.

rtype

TypeVar(RS, bound= start_path)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.modeling_cmd.start_path.to_dict>`\ \(\)

__init__([annotation_id, options, type])

Method generated by attrs for class update_annotation.

rtype

TypeVar(AZ, bound= update_annotation)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd.update_annotation.__init__>`\ \(\[annotation\_id\, options\, type\]\)

:py:obj:`to_dict <kittycad.models.modeling_cmd.update_annotation.to_dict>`\ \(\)

annotation_id

options

type

__add__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__annotations__ (kittycad.models.modeling_cmd_id.ModelingCmdId attribute)

__contains__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__dict__ (kittycad.models.modeling_cmd_id.ModelingCmdId attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd_id', '__str__': <function ModelingCmdId.__str__>, '__dict__': <attribute '__dict__' of 'ModelingCmdId' objects>, '__weakref__': <attribute '__weakref__' of 'ModelingCmdId' objects>, '__doc__': None, '__annotations__': {}})

__format__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__getattribute__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__getitem__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__getnewargs__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__hash__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__iter__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__len__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__mod__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__module__ (kittycad.models.modeling_cmd_id.ModelingCmdId attribute)

__mul__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__new__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__repr__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__rmod__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__rmul__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__sizeof__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__str__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

capitalize() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

casefold() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

endswith() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

expandtabs() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

format_map() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isalnum() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isalpha() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isascii() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isdecimal() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isdigit() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isidentifier() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

islower() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isnumeric() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isprintable() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isspace() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

istitle() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

isupper() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

maketrans() (kittycad.models.modeling_cmd_id.ModelingCmdId static method)

partition() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

removeprefix() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

removesuffix() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

replace() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

rpartition() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

splitlines() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

startswith() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

swapcase() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

translate() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__init__() (kittycad.models.modeling_cmd_id.ModelingCmdId method)

__init__()

isalnum()

isalpha()

isascii()

isdigit()

islower()

isspace()

istitle()

isupper()

lower()

maketrans

title()

upper()

:py:obj:`center <kittycad.models.modeling_cmd_id.ModelingCmdId.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.modeling_cmd_id.ModelingCmdId.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.modeling_cmd_id.ModelingCmdId.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.modeling_cmd_id.ModelingCmdId.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.modeling_cmd_id.ModelingCmdId.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.modeling_cmd_id.ModelingCmdId.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.modeling_cmd_id.ModelingCmdId.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.modeling_cmd_id.ModelingCmdId.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.modeling_cmd_id.ModelingCmdId.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.modeling_cmd_id.ModelingCmdId.isascii>`\ \(\)

:py:obj:`isdigit <kittycad.models.modeling_cmd_id.ModelingCmdId.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.modeling_cmd_id.ModelingCmdId.islower>`\ \(\)

:py:obj:`isspace <kittycad.models.modeling_cmd_id.ModelingCmdId.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.modeling_cmd_id.ModelingCmdId.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.modeling_cmd_id.ModelingCmdId.isupper>`\ \(\)

:py:obj:`join <kittycad.models.modeling_cmd_id.ModelingCmdId.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.modeling_cmd_id.ModelingCmdId.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.modeling_cmd_id.ModelingCmdId.lower>`\ \(\)

:py:obj:`partition <kittycad.models.modeling_cmd_id.ModelingCmdId.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.modeling_cmd_id.ModelingCmdId.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.modeling_cmd_id.ModelingCmdId.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.modeling_cmd_id.ModelingCmdId.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.modeling_cmd_id.ModelingCmdId.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.modeling_cmd_id.ModelingCmdId.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.modeling_cmd_id.ModelingCmdId.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.modeling_cmd_id.ModelingCmdId.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.modeling_cmd_id.ModelingCmdId.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.modeling_cmd_id.ModelingCmdId.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.modeling_cmd_id.ModelingCmdId.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.modeling_cmd_id.ModelingCmdId.title>`\ \(\)

:py:obj:`translate <kittycad.models.modeling_cmd_id.ModelingCmdId.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.modeling_cmd_id.ModelingCmdId.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.modeling_cmd_id.ModelingCmdId.zfill>`\ \(width\, \/\)

ModelingCmdReq([cmd, cmd_id])

A graphics command submitted to the KittyCAD engine via the Modeling API.

:py:obj:`ModelingCmdReq <kittycad.models.modeling_cmd_req.ModelingCmdReq>`\ \(\[cmd\, cmd\_id\]\)

ModelingCmdReq(cmd=<kittycad.types.Unset object>, cmd_id=<kittycad.types.Unset object>)

(cmd=<kittycad.types.Unset object>, cmd_id=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

__attrs_attrs__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

(Attribute(name='cmd', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd.start_path, kittycad.models.modeling_cmd.move_path_pen, kittycad.models.modeling_cmd.extend_path, kittycad.models.modeling_cmd.extrude, kittycad.models.modeling_cmd.close_path, kittycad.models.modeling_cmd.camera_drag_start, kittycad.models.modeling_cmd.camera_drag_move, kittycad.models.modeling_cmd.camera_drag_end, kittycad.models.modeling_cmd.default_camera_look_at, kittycad.models.modeling_cmd.default_camera_enable_sketch_mode, kittycad.models.modeling_cmd.default_camera_disable_sketch_mode, kittycad.models.modeling_cmd.export, kittycad.models.modeling_cmd.entity_get_parent_id, kittycad.models.modeling_cmd.entity_get_num_children, kittycad.models.modeling_cmd.entity_get_child_uuid, kittycad.models.modeling_cmd.entity_get_all_child_uuids, kittycad.models.modeling_cmd.edit_mode_enter, kittycad.models.modeling_cmd.edit_mode_exit, kittycad.models.modeling_cmd.select_with_point, kittycad.models.modeling_cmd.select_clear, kittycad.models.modeling_cmd.select_add, kittycad.models.modeling_cmd.select_remove, kittycad.models.modeling_cmd.select_replace, kittycad.models.modeling_cmd.select_get, kittycad.models.modeling_cmd.highlight_set_entity, kittycad.models.modeling_cmd.highlight_set_entities, kittycad.models.modeling_cmd.new_annotation, kittycad.models.modeling_cmd.update_annotation, kittycad.models.modeling_cmd.object_visible, kittycad.models.modeling_cmd.get_entity_type, kittycad.models.modeling_cmd.solid3d_get_all_edge_faces, kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges, kittycad.models.modeling_cmd.solid3d_get_opposite_edge, kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge, kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmd'), Attribute(name='cmd_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmd_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__delitem__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__dict__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd_req', '__annotations__': {'cmd': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd.start_path, kittycad.models.modeling_cmd.move_path_pen, kittycad.models.modeling_cmd.extend_path, kittycad.models.modeling_cmd.extrude, kittycad.models.modeling_cmd.close_path, kittycad.models.modeling_cmd.camera_drag_start, kittycad.models.modeling_cmd.camera_drag_move, kittycad.models.modeling_cmd.camera_drag_end, kittycad.models.modeling_cmd.default_camera_look_at, kittycad.models.modeling_cmd.default_camera_enable_sketch_mode, kittycad.models.modeling_cmd.default_camera_disable_sketch_mode, kittycad.models.modeling_cmd.export, kittycad.models.modeling_cmd.entity_get_parent_id, kittycad.models.modeling_cmd.entity_get_num_children, kittycad.models.modeling_cmd.entity_get_child_uuid, kittycad.models.modeling_cmd.entity_get_all_child_uuids, kittycad.models.modeling_cmd.edit_mode_enter, kittycad.models.modeling_cmd.edit_mode_exit, kittycad.models.modeling_cmd.select_with_point, kittycad.models.modeling_cmd.select_clear, kittycad.models.modeling_cmd.select_add, kittycad.models.modeling_cmd.select_remove, kittycad.models.modeling_cmd.select_replace, kittycad.models.modeling_cmd.select_get, kittycad.models.modeling_cmd.highlight_set_entity, kittycad.models.modeling_cmd.highlight_set_entities, kittycad.models.modeling_cmd.new_annotation, kittycad.models.modeling_cmd.update_annotation, kittycad.models.modeling_cmd.object_visible, kittycad.models.modeling_cmd.get_entity_type, kittycad.models.modeling_cmd.solid3d_get_all_edge_faces, kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges, kittycad.models.modeling_cmd.solid3d_get_opposite_edge, kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge, kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge], 'cmd_id': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A graphics command submitted to the KittyCAD engine via the Modeling API.', 'to_dict': <function ModelingCmdReq.to_dict>, 'from_dict': <classmethod(<function ModelingCmdReq.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ModelingCmdReq.__getitem__>, '__setitem__': <function ModelingCmdReq.__setitem__>, '__delitem__': <function ModelingCmdReq.__delitem__>, '__contains__': <function ModelingCmdReq.__contains__>, '__dict__': <attribute '__dict__' of 'ModelingCmdReq' objects>, '__weakref__': <attribute '__weakref__' of 'ModelingCmdReq' objects>, '__attrs_attrs__': (Attribute(name='cmd', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd.start_path, kittycad.models.modeling_cmd.move_path_pen, kittycad.models.modeling_cmd.extend_path, kittycad.models.modeling_cmd.extrude, kittycad.models.modeling_cmd.close_path, kittycad.models.modeling_cmd.camera_drag_start, kittycad.models.modeling_cmd.camera_drag_move, kittycad.models.modeling_cmd.camera_drag_end, kittycad.models.modeling_cmd.default_camera_look_at, kittycad.models.modeling_cmd.default_camera_enable_sketch_mode, kittycad.models.modeling_cmd.default_camera_disable_sketch_mode, kittycad.models.modeling_cmd.export, kittycad.models.modeling_cmd.entity_get_parent_id, kittycad.models.modeling_cmd.entity_get_num_children, kittycad.models.modeling_cmd.entity_get_child_uuid, kittycad.models.modeling_cmd.entity_get_all_child_uuids, kittycad.models.modeling_cmd.edit_mode_enter, kittycad.models.modeling_cmd.edit_mode_exit, kittycad.models.modeling_cmd.select_with_point, kittycad.models.modeling_cmd.select_clear, kittycad.models.modeling_cmd.select_add, kittycad.models.modeling_cmd.select_remove, kittycad.models.modeling_cmd.select_replace, kittycad.models.modeling_cmd.select_get, kittycad.models.modeling_cmd.highlight_set_entity, kittycad.models.modeling_cmd.highlight_set_entities, kittycad.models.modeling_cmd.new_annotation, kittycad.models.modeling_cmd.update_annotation, kittycad.models.modeling_cmd.object_visible, kittycad.models.modeling_cmd.get_entity_type, kittycad.models.modeling_cmd.solid3d_get_all_edge_faces, kittycad.models.modeling_cmd.solid3d_get_all_opposite_edges, kittycad.models.modeling_cmd.solid3d_get_opposite_edge, kittycad.models.modeling_cmd.solid3d_get_next_adjacent_edge, kittycad.models.modeling_cmd.solid3d_get_prev_adjacent_edge], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmd'), Attribute(name='cmd_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmd_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ModelingCmdReq.__repr__>, '__eq__': <function ModelingCmdReq.__eq__>, '__ne__': <function ModelingCmdReq.__ne__>, '__lt__': <function ModelingCmdReq.__lt__>, '__le__': <function ModelingCmdReq.__le__>, '__gt__': <function ModelingCmdReq.__gt__>, '__ge__': <function ModelingCmdReq.__ge__>, '__hash__': None, '__init__': <function ModelingCmdReq.__init__>, '__match_args__': ('cmd', 'cmd_id')})

__eq__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__ge__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__getitem__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__gt__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__hash__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

__init__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

ModelingCmdReq.__init__(cmd=<kittycad.types.Unset object>, cmd_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__lt__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__match_args__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

__module__ (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

__ne__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__repr__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__setitem__() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

additional_keys (kittycad.models.modeling_cmd_req.ModelingCmdReq property)

cmd_id (kittycad.models.modeling_cmd_req.ModelingCmdReq attribute)

from_dict() (kittycad.models.modeling_cmd_req.ModelingCmdReq class method)

to_dict() (kittycad.models.modeling_cmd_req.ModelingCmdReq method)

__init__([cmd, cmd_id])

Method generated by attrs for class ModelingCmdReq.

rtype

TypeVar(ZG, bound= ModelingCmdReq)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_cmd_req.ModelingCmdReq.__init__>`\ \(\[cmd\, cmd\_id\]\)

ModelingCmdReqBatch([cmds])

A batch set of graphics commands submitted to the KittyCAD engine via the Modeling API.

ModelingCmdReqBatch (class in kittycad.models.modeling_cmd_req_batch)

{'additional_properties': typing.Dict[str, typing.Any], 'cmds': typing.Union[kittycad.types.Unset, typing.Any]}

(Attribute(name='cmds', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmds'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_cmd_req_batch', '__annotations__': {'cmds': typing.Union[kittycad.types.Unset, typing.Any], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A batch set of graphics commands submitted to the KittyCAD engine via the Modeling API.', 'to_dict': <function ModelingCmdReqBatch.to_dict>, 'from_dict': <classmethod(<function ModelingCmdReqBatch.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ModelingCmdReqBatch.__getitem__>, '__setitem__': <function ModelingCmdReqBatch.__setitem__>, '__delitem__': <function ModelingCmdReqBatch.__delitem__>, '__contains__': <function ModelingCmdReqBatch.__contains__>, '__dict__': <attribute '__dict__' of 'ModelingCmdReqBatch' objects>, '__weakref__': <attribute '__weakref__' of 'ModelingCmdReqBatch' objects>, '__attrs_attrs__': (Attribute(name='cmds', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cmds'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ModelingCmdReqBatch.__repr__>, '__eq__': <function ModelingCmdReqBatch.__eq__>, '__ne__': <function ModelingCmdReqBatch.__ne__>, '__lt__': <function ModelingCmdReqBatch.__lt__>, '__le__': <function ModelingCmdReqBatch.__le__>, '__gt__': <function ModelingCmdReqBatch.__gt__>, '__ge__': <function ModelingCmdReqBatch.__ge__>, '__hash__': None, '__init__': <function ModelingCmdReqBatch.__init__>, '__match_args__': ('cmds',)})

__eq__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__ge__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__gt__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__hash__ (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch attribute)

__init__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__le__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__lt__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__ne__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__repr__() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

cmds (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch attribute)

from_dict() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch class method)

to_dict() (kittycad.models.modeling_cmd_req_batch.ModelingCmdReqBatch method)

__init__([cmds])

Method generated by attrs for class ModelingCmdReqBatch.

rtype

TypeVar(LF, bound= ModelingCmdReqBatch)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``LF``, bound= ModelingCmdReqBatch)

ModelingError([error_code, ...])

Why a command submitted to the Modeling API failed.

:py:obj:`ModelingError <kittycad.models.modeling_error.ModelingError>`\ \(\[error\_code\, ...\]\)

ModelingError(error_code=<kittycad.types.Unset object>, external_message=<kittycad.types.Unset object>, internal_message=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>)

(error_code=<kittycad.types.Unset object>, external_message=<kittycad.types.Unset object>, internal_message=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.modeling_error.ModelingError attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'error_code': typing.Union[kittycad.types.Unset, str], 'external_message': typing.Union[kittycad.types.Unset, str], 'internal_message': typing.Union[kittycad.types.Unset, str], 'status_code': typing.Union[kittycad.types.Unset, int]}

__attrs_attrs__ (kittycad.models.modeling_error.ModelingError attribute)

(Attribute(name='error_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error_code'), Attribute(name='external_message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='external_message'), Attribute(name='internal_message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='internal_message'), Attribute(name='status_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_error.ModelingError method)

__delitem__() (kittycad.models.modeling_error.ModelingError method)

__dict__ (kittycad.models.modeling_error.ModelingError attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_error', '__annotations__': {'error_code': typing.Union[kittycad.types.Unset, str], 'external_message': typing.Union[kittycad.types.Unset, str], 'internal_message': typing.Union[kittycad.types.Unset, str], 'status_code': typing.Union[kittycad.types.Unset, int], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Why a command submitted to the Modeling API failed.', 'to_dict': <function ModelingError.to_dict>, 'from_dict': <classmethod(<function ModelingError.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ModelingError.__getitem__>, '__setitem__': <function ModelingError.__setitem__>, '__delitem__': <function ModelingError.__delitem__>, '__contains__': <function ModelingError.__contains__>, '__dict__': <attribute '__dict__' of 'ModelingError' objects>, '__weakref__': <attribute '__weakref__' of 'ModelingError' objects>, '__attrs_attrs__': (Attribute(name='error_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error_code'), Attribute(name='external_message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='external_message'), Attribute(name='internal_message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='internal_message'), Attribute(name='status_code', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ModelingError.__repr__>, '__eq__': <function ModelingError.__eq__>, '__ne__': <function ModelingError.__ne__>, '__lt__': <function ModelingError.__lt__>, '__le__': <function ModelingError.__le__>, '__gt__': <function ModelingError.__gt__>, '__ge__': <function ModelingError.__ge__>, '__hash__': None, '__init__': <function ModelingError.__init__>, '__match_args__': ('error_code', 'external_message', 'internal_message', 'status_code')})

__getitem__() (kittycad.models.modeling_error.ModelingError method)

__hash__ (kittycad.models.modeling_error.ModelingError attribute)

__init__() (kittycad.models.modeling_error.ModelingError method)

ModelingError.__init__(error_code=<kittycad.types.Unset object>, external_message=<kittycad.types.Unset object>, internal_message=<kittycad.types.Unset object>, status_code=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.modeling_error.ModelingError attribute)

('error_code', 'external_message', 'internal_message', 'status_code')

__module__ (kittycad.models.modeling_error.ModelingError attribute)

__repr__() (kittycad.models.modeling_error.ModelingError method)

__setitem__() (kittycad.models.modeling_error.ModelingError method)

additional_keys (kittycad.models.modeling_error.ModelingError property)

additional_properties (kittycad.models.modeling_error.ModelingError attribute)

error_code (kittycad.models.modeling_error.ModelingError attribute)

external_message (kittycad.models.modeling_error.ModelingError attribute)

from_dict() (kittycad.models.modeling_error.ModelingError class method)

internal_message (kittycad.models.modeling_error.ModelingError attribute)

status_code (kittycad.models.modeling_error.ModelingError attribute)

__init__([error_code, external_message, ...])

Method generated by attrs for class ModelingError.

rtype

TypeVar(CS, bound= ModelingError)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.modeling_error.ModelingError.__init__>`\ \(\[error\_code\, external\_message\, ...\]\)

:py:obj:`to_dict <kittycad.models.modeling_error.ModelingError.to_dict>`\ \(\)

external_message

internal_message

cancelled([what_failed])

Method generated by attrs for class cancelled.

__annotations__ (kittycad.models.modeling_outcome.cancelled attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'what_failed': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId]}

__attrs_attrs__ (kittycad.models.modeling_outcome.cancelled attribute)

(Attribute(name='what_failed', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='what_failed'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_outcome.cancelled method)

__delitem__() (kittycad.models.modeling_outcome.cancelled method)

mappingproxy({'__module__': 'kittycad.models.modeling_outcome', '__annotations__': {'what_failed': typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], 'additional_properties': typing.Dict[str, typing.Any]}, 'to_dict': <function cancelled.to_dict>, 'from_dict': <classmethod(<function cancelled.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function cancelled.__getitem__>, '__setitem__': <function cancelled.__setitem__>, '__delitem__': <function cancelled.__delitem__>, '__contains__': <function cancelled.__contains__>, '__dict__': <attribute '__dict__' of 'cancelled' objects>, '__weakref__': <attribute '__weakref__' of 'cancelled' objects>, '__doc__': None, '__attrs_attrs__': (Attribute(name='what_failed', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.modeling_cmd_id.ModelingCmdId], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='what_failed'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function cancelled.__repr__>, '__eq__': <function cancelled.__eq__>, '__ne__': <function cancelled.__ne__>, '__lt__': <function cancelled.__lt__>, '__le__': <function cancelled.__le__>, '__gt__': <function cancelled.__gt__>, '__ge__': <function cancelled.__ge__>, '__hash__': None, '__init__': <function cancelled.__init__>, '__match_args__': ('what_failed',)})

__getitem__() (kittycad.models.modeling_outcome.cancelled method)

__match_args__ (kittycad.models.modeling_outcome.cancelled attribute)

__module__ (kittycad.models.modeling_outcome.cancelled attribute)

__setitem__() (kittycad.models.modeling_outcome.cancelled method)

additional_keys (kittycad.models.modeling_outcome.cancelled property)

additional_properties (kittycad.models.modeling_outcome.cancelled attribute)

from_dict() (kittycad.models.modeling_outcome.cancelled class method)

what_failed (kittycad.models.modeling_outcome.cancelled attribute)

__init__([what_failed])

rtype

TypeVar(GN, bound= cancelled)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.modeling_outcome.cancelled.to_dict>`\ \(\)

ModelingOutcomes([outcomes])

The result from a batch of modeling commands.

__annotations__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'outcomes': typing.Union[kittycad.types.Unset, typing.Any]}

__attrs_attrs__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

(Attribute(name='outcomes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outcomes'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__delitem__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__dict__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

mappingproxy({'__module__': 'kittycad.models.modeling_outcomes', '__annotations__': {'outcomes': typing.Union[kittycad.types.Unset, typing.Any], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The result from a batch of modeling commands.', 'to_dict': <function ModelingOutcomes.to_dict>, 'from_dict': <classmethod(<function ModelingOutcomes.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ModelingOutcomes.__getitem__>, '__setitem__': <function ModelingOutcomes.__setitem__>, '__delitem__': <function ModelingOutcomes.__delitem__>, '__contains__': <function ModelingOutcomes.__contains__>, '__dict__': <attribute '__dict__' of 'ModelingOutcomes' objects>, '__weakref__': <attribute '__weakref__' of 'ModelingOutcomes' objects>, '__attrs_attrs__': (Attribute(name='outcomes', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='outcomes'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ModelingOutcomes.__repr__>, '__eq__': <function ModelingOutcomes.__eq__>, '__ne__': <function ModelingOutcomes.__ne__>, '__lt__': <function ModelingOutcomes.__lt__>, '__le__': <function ModelingOutcomes.__le__>, '__gt__': <function ModelingOutcomes.__gt__>, '__ge__': <function ModelingOutcomes.__ge__>, '__hash__': None, '__init__': <function ModelingOutcomes.__init__>, '__match_args__': ('outcomes',)})

__eq__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__ge__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__getitem__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__gt__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__hash__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

__init__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__le__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__lt__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__match_args__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

__module__ (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

__ne__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__repr__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__setitem__() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

additional_keys (kittycad.models.modeling_outcomes.ModelingOutcomes property)

from_dict() (kittycad.models.modeling_outcomes.ModelingOutcomes class method)

outcomes (kittycad.models.modeling_outcomes.ModelingOutcomes attribute)

to_dict() (kittycad.models.modeling_outcomes.ModelingOutcomes method)

__init__([outcomes])

Method generated by attrs for class ModelingOutcomes.

rtype

TypeVar(GD, bound= ModelingOutcomes)

to_dict()

rtype

NewAddress([city, country, state, street1, ...])

The struct that is used to create a new record.

:py:obj:`NewAddress <kittycad.models.new_address.NewAddress>`\ \(\[city\, country\, state\, street1\, ...\]\)

NewAddress(city=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, state=<kittycad.types.Unset object>, street1=<kittycad.types.Unset object>, street2=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, zip=<kittycad.types.Unset object>)

(city=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, state=<kittycad.types.Unset object>, street1=<kittycad.types.Unset object>, street2=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, zip=<kittycad.types.Unset object>)

The struct that is used to create a new record. This is automatically generated and has all the same fields as the main struct only it is missing the `id`.

The struct that is used to create a new record. This is automatically generated and has all the same fields as the main struct only it is missing the 

__annotations__ (kittycad.models.new_address.NewAddress attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'city': typing.Union[kittycad.types.Unset, str], 'country': typing.Union[kittycad.types.Unset, kittycad.models.country_code.CountryCode], 'state': typing.Union[kittycad.types.Unset, str], 'street1': typing.Union[kittycad.types.Unset, str], 'street2': typing.Union[kittycad.types.Unset, str], 'user_id': typing.Union[kittycad.types.Unset, str], 'zip': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.new_address.NewAddress attribute)

(Attribute(name='city', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='city'), Attribute(name='country', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.country_code.CountryCode], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='country'), Attribute(name='state', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='state'), Attribute(name='street1', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='street1'), Attribute(name='street2', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='street2'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='zip', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='zip'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.new_address', '__annotations__': {'city': typing.Union[kittycad.types.Unset, str], 'country': typing.Union[kittycad.types.Unset, kittycad.models.country_code.CountryCode], 'state': typing.Union[kittycad.types.Unset, str], 'street1': typing.Union[kittycad.types.Unset, str], 'street2': typing.Union[kittycad.types.Unset, str], 'user_id': typing.Union[kittycad.types.Unset, str], 'zip': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The struct that is used to create a new record. This is automatically generated and has all the same fields as the main struct only it is missing the `id`.', 'to_dict': <function NewAddress.to_dict>, 'from_dict': <classmethod(<function NewAddress.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function NewAddress.__getitem__>, '__setitem__': <function NewAddress.__setitem__>, '__delitem__': <function NewAddress.__delitem__>, '__contains__': <function NewAddress.__contains__>, '__dict__': <attribute '__dict__' of 'NewAddress' objects>, '__weakref__': <attribute '__weakref__' of 'NewAddress' objects>, '__attrs_attrs__': (Attribute(name='city', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='city'), Attribute(name='country', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.country_code.CountryCode], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='country'), Attribute(name='state', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='state'), Attribute(name='street1', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='street1'), Attribute(name='street2', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='street2'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='zip', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='zip'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function NewAddress.__repr__>, '__eq__': <function NewAddress.__eq__>, '__ne__': <function NewAddress.__ne__>, '__lt__': <function NewAddress.__lt__>, '__le__': <function NewAddress.__le__>, '__gt__': <function NewAddress.__gt__>, '__ge__': <function NewAddress.__ge__>, '__hash__': None, '__init__': <function NewAddress.__init__>, '__match_args__': ('city', 'country', 'state', 'street1', 'street2', 'user_id', 'zip')})

NewAddress.__init__(city=<kittycad.types.Unset object>, country=<kittycad.types.Unset object>, state=<kittycad.types.Unset object>, street1=<kittycad.types.Unset object>, street2=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>, zip=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.new_address.NewAddress attribute)

('city', 'country', 'state', 'street1', 'street2', 'user_id', 'zip')

additional_keys (kittycad.models.new_address.NewAddress property)

additional_properties (kittycad.models.new_address.NewAddress attribute)

from_dict() (kittycad.models.new_address.NewAddress class method)

__init__([city, country, state, street1, ...])

Method generated by attrs for class NewAddress.

rtype

TypeVar(VJ, bound= NewAddress)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.new_address.NewAddress.__init__>`\ \(\[city\, country\, state\, street1\, ...\]\)

:py:obj:`to_dict <kittycad.models.new_address.NewAddress.to_dict>`\ \(\)

city

country

state

street1

street2

user_id

zip

OAuth2ClientInfo([csrf_token, ...])

Information about an OAuth 2.0 client.

:py:obj:`OAuth2ClientInfo <kittycad.models.o_auth2_client_info.OAuth2ClientInfo>`\ \(\[csrf\_token\, ...\]\)

OAuth2ClientInfo(csrf_token=<kittycad.types.Unset object>, pkce_code_verifier=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

(csrf_token=<kittycad.types.Unset object>, pkce_code_verifier=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'csrf_token': typing.Union[kittycad.types.Unset, str], 'pkce_code_verifier': typing.Union[kittycad.types.Unset, str], 'url': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

(Attribute(name='csrf_token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='csrf_token'), Attribute(name='pkce_code_verifier', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pkce_code_verifier'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__delitem__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__dict__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

mappingproxy({'__module__': 'kittycad.models.o_auth2_client_info', '__annotations__': {'csrf_token': typing.Union[kittycad.types.Unset, str], 'pkce_code_verifier': typing.Union[kittycad.types.Unset, str], 'url': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Information about an OAuth 2.0 client.', 'to_dict': <function OAuth2ClientInfo.to_dict>, 'from_dict': <classmethod(<function OAuth2ClientInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function OAuth2ClientInfo.__getitem__>, '__setitem__': <function OAuth2ClientInfo.__setitem__>, '__delitem__': <function OAuth2ClientInfo.__delitem__>, '__contains__': <function OAuth2ClientInfo.__contains__>, '__dict__': <attribute '__dict__' of 'OAuth2ClientInfo' objects>, '__weakref__': <attribute '__weakref__' of 'OAuth2ClientInfo' objects>, '__attrs_attrs__': (Attribute(name='csrf_token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='csrf_token'), Attribute(name='pkce_code_verifier', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='pkce_code_verifier'), Attribute(name='url', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='url'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function OAuth2ClientInfo.__repr__>, '__eq__': <function OAuth2ClientInfo.__eq__>, '__ne__': <function OAuth2ClientInfo.__ne__>, '__lt__': <function OAuth2ClientInfo.__lt__>, '__le__': <function OAuth2ClientInfo.__le__>, '__gt__': <function OAuth2ClientInfo.__gt__>, '__ge__': <function OAuth2ClientInfo.__ge__>, '__hash__': None, '__init__': <function OAuth2ClientInfo.__init__>, '__match_args__': ('csrf_token', 'pkce_code_verifier', 'url')})

__eq__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__ge__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__getitem__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__gt__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__hash__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

__init__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

OAuth2ClientInfo.__init__(csrf_token=<kittycad.types.Unset object>, pkce_code_verifier=<kittycad.types.Unset object>, url=<kittycad.types.Unset object>)

__le__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__lt__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__match_args__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

__module__ (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

__ne__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__repr__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

__setitem__() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

additional_keys (kittycad.models.o_auth2_client_info.OAuth2ClientInfo property)

csrf_token (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

from_dict() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo class method)

to_dict() (kittycad.models.o_auth2_client_info.OAuth2ClientInfo method)

url (kittycad.models.o_auth2_client_info.OAuth2ClientInfo attribute)

__init__([csrf_token, pkce_code_verifier, url])

Method generated by attrs for class OAuth2ClientInfo.

rtype

TypeVar(OX, bound= OAuth2ClientInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.o_auth2_client_info.OAuth2ClientInfo.__init__>`\ \(\[csrf\_token\, pkce\_code\_verifier\, url\]\)

csrf_token

pkce_code_verifier

url

OAuth2GrantType(value[, names, module, ...])

An OAuth 2.0 Grant Type.

:py:obj:`OAuth2GrantType <kittycad.models.o_auth2_grant_type.OAuth2GrantType>`\ \(value\[\, names\, module\, ...\]\)

OAuth2GrantType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

An OAuth 2.0 Grant Type. These are documented here: <https://oauth.net/2/grant-types/>.

__add__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__annotations__ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

__contains__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__dict__ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.o_auth2_grant_type', '__doc__': 'An OAuth 2.0 Grant Type. These are documented here: <https://oauth.net/2/grant-types/>.', '__str__': <function OAuth2GrantType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE'], '_member_map_': {'URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE': <OAuth2GrantType.URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE: 'urn:ietf:params:oauth:grant-type:device_code'>}, '_value2member_map_': {'urn:ietf:params:oauth:grant-type:device_code': <OAuth2GrantType.URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE: 'urn:ietf:params:oauth:grant-type:device_code'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'OAuth2GrantType' objects>, '__weakref__': <attribute '__weakref__' of 'OAuth2GrantType' objects>, 'URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE': <OAuth2GrantType.URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE: 'urn:ietf:params:oauth:grant-type:device_code'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__eq__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__format__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__ge__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__getattribute__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__getitem__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__getnewargs__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__gt__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__hash__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__init__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__iter__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__le__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__len__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__lt__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__mod__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__module__ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

__mul__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__ne__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__new__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__reduce_ex__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__repr__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__rmod__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__rmul__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__sizeof__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

__str__() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

OAuth2GrantType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

_member_names_ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

_member_type_ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

_new_member_() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

_use_args_ (kittycad.models.o_auth2_grant_type.OAuth2GrantType attribute)

_value_repr_() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

capitalize() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

casefold() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

center() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

count() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

encode() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

endswith() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

expandtabs() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

find() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

format() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

format_map() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

index() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isalnum() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isalpha() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isascii() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isdecimal() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isdigit() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isidentifier() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

islower() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isnumeric() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isprintable() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isspace() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

istitle() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

isupper() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

join() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

ljust() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

lower() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

lstrip() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

maketrans() (kittycad.models.o_auth2_grant_type.OAuth2GrantType static method)

partition() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

removeprefix() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

removesuffix() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

replace() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rfind() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rindex() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rjust() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rpartition() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rsplit() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

rstrip() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

split() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

splitlines() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

startswith() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

strip() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

swapcase() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

title() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

translate() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

upper() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

zfill() (kittycad.models.o_auth2_grant_type.OAuth2GrantType method)

:py:obj:`__init__ <kittycad.models.o_auth2_grant_type.OAuth2GrantType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.o_auth2_grant_type.OAuth2GrantType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.o_auth2_grant_type.OAuth2GrantType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.o_auth2_grant_type.OAuth2GrantType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.o_auth2_grant_type.OAuth2GrantType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.o_auth2_grant_type.OAuth2GrantType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.o_auth2_grant_type.OAuth2GrantType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.o_auth2_grant_type.OAuth2GrantType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.o_auth2_grant_type.OAuth2GrantType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.o_auth2_grant_type.OAuth2GrantType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.o_auth2_grant_type.OAuth2GrantType.lower>`\ \(\)

:py:obj:`partition <kittycad.models.o_auth2_grant_type.OAuth2GrantType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.o_auth2_grant_type.OAuth2GrantType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.o_auth2_grant_type.OAuth2GrantType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.o_auth2_grant_type.OAuth2GrantType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.o_auth2_grant_type.OAuth2GrantType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.o_auth2_grant_type.OAuth2GrantType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.o_auth2_grant_type.OAuth2GrantType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.o_auth2_grant_type.OAuth2GrantType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.o_auth2_grant_type.OAuth2GrantType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.o_auth2_grant_type.OAuth2GrantType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.o_auth2_grant_type.OAuth2GrantType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.o_auth2_grant_type.OAuth2GrantType.title>`\ \(\)

:py:obj:`translate <kittycad.models.o_auth2_grant_type.OAuth2GrantType.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.o_auth2_grant_type.OAuth2GrantType.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.o_auth2_grant_type.OAuth2GrantType.zfill>`\ \(width\, \/\)

empty([type])

An empty response, used for any command that does not explicitly have a response defined here.

entity_get_all_child_uuids([entity_ids, type])

The response from the EntityGetAllChildUuids command.

entity_get_child_uuid([entity_id, type])

The response from the EntityGetChildUuid command.

entity_get_num_children([num, type])

The response from the EntityGetNumChildren command.

The response from the EntityGetParentId command.

export([files, type])

The response from the Export command.

get_entity_type([entity_type, type])

The response from the GetEntityType command.

highlight_set_entity([entity_id, sequence, type])

The response from the HighlightSetEntity command.

select_get([entity_ids, type])

The response from the SelectGet command.

select_with_point([entity_id, type])

The response from the SelectWithPoint command.

solid3d_get_all_edge_faces([faces, type])

The response from the Solid3dGetAllEdgeFaces command.

solid3d_get_all_opposite_edges([edges, type])

The response from the Solid3dGetAllOppositeEdges command.

solid3d_get_next_adjacent_edge([edge, type])

The response from the Solid3dGetNextAdjacentEdge command.

solid3d_get_opposite_edge([edge, type])

The response from the Solid3dGetOppositeEdge command.

solid3d_get_prev_adjacent_edge([edge, type])

The response from the Solid3dGetPrevAdjacentEdge command.

:py:obj:`empty <kittycad.models.ok_modeling_cmd_response.empty>`\ \(\[type\]\)

:py:obj:`entity_get_num_children <kittycad.models.ok_modeling_cmd_response.entity_get_num_children>`\ \(\[num\, type\]\)

:py:obj:`export <kittycad.models.ok_modeling_cmd_response.export>`\ \(\[files\, type\]\)

:py:obj:`get_entity_type <kittycad.models.ok_modeling_cmd_response.get_entity_type>`\ \(\[entity\_type\, type\]\)

:py:obj:`highlight_set_entity <kittycad.models.ok_modeling_cmd_response.highlight_set_entity>`\ \(\[entity\_id\, sequence\, type\]\)

:py:obj:`select_get <kittycad.models.ok_modeling_cmd_response.select_get>`\ \(\[entity\_ids\, type\]\)

:py:obj:`select_with_point <kittycad.models.ok_modeling_cmd_response.select_with_point>`\ \(\[entity\_id\, type\]\)

__annotations__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

__attrs_attrs__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

(Attribute(name='type', default='empty', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ok_modeling_cmd_response.empty method)

__delitem__() (kittycad.models.ok_modeling_cmd_response.empty method)

__dict__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An empty response, used for any command that does not explicitly have a response defined here.', 'to_dict': <function empty.to_dict>, 'from_dict': <classmethod(<function empty.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function empty.__getitem__>, '__setitem__': <function empty.__setitem__>, '__delitem__': <function empty.__delitem__>, '__contains__': <function empty.__contains__>, '__dict__': <attribute '__dict__' of 'empty' objects>, '__weakref__': <attribute '__weakref__' of 'empty' objects>, '__attrs_attrs__': (Attribute(name='type', default='empty', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function empty.__repr__>, '__eq__': <function empty.__eq__>, '__ne__': <function empty.__ne__>, '__lt__': <function empty.__lt__>, '__le__': <function empty.__le__>, '__gt__': <function empty.__gt__>, '__ge__': <function empty.__ge__>, '__hash__': None, '__init__': <function empty.__init__>, '__match_args__': ('type',)})

__eq__() (kittycad.models.ok_modeling_cmd_response.empty method)

__ge__() (kittycad.models.ok_modeling_cmd_response.empty method)

__getitem__() (kittycad.models.ok_modeling_cmd_response.empty method)

__gt__() (kittycad.models.ok_modeling_cmd_response.empty method)

__hash__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.empty method)

__le__() (kittycad.models.ok_modeling_cmd_response.empty method)

__lt__() (kittycad.models.ok_modeling_cmd_response.empty method)

__match_args__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

__module__ (kittycad.models.ok_modeling_cmd_response.empty attribute)

__ne__() (kittycad.models.ok_modeling_cmd_response.empty method)

__repr__() (kittycad.models.ok_modeling_cmd_response.empty method)

__setitem__() (kittycad.models.ok_modeling_cmd_response.empty method)

additional_keys (kittycad.models.ok_modeling_cmd_response.empty property)

additional_properties (kittycad.models.ok_modeling_cmd_response.empty attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.empty class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.empty method)

entity_get_all_child_uuids (class in kittycad.models.ok_modeling_cmd_response)

(entity_ids=<kittycad.types.Unset object>, type='entity_get_all_child_uuids')

{'additional_properties': typing.Dict[str, typing.Any], 'entity_ids': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>}

(Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='type', default='entity_get_all_child_uuids', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_ids': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `EntityGetAllChildUuids` command.', 'to_dict': <function entity_get_all_child_uuids.to_dict>, 'from_dict': <classmethod(<function entity_get_all_child_uuids.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_all_child_uuids.__getitem__>, '__setitem__': <function entity_get_all_child_uuids.__setitem__>, '__delitem__': <function entity_get_all_child_uuids.__delitem__>, '__contains__': <function entity_get_all_child_uuids.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_all_child_uuids' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_all_child_uuids' objects>, '__attrs_attrs__': (Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='type', default='entity_get_all_child_uuids', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_all_child_uuids.__repr__>, '__eq__': <function entity_get_all_child_uuids.__eq__>, '__ne__': <function entity_get_all_child_uuids.__ne__>, '__lt__': <function entity_get_all_child_uuids.__lt__>, '__le__': <function entity_get_all_child_uuids.__le__>, '__gt__': <function entity_get_all_child_uuids.__gt__>, '__ge__': <function entity_get_all_child_uuids.__ge__>, '__hash__': None, '__init__': <function entity_get_all_child_uuids.__init__>, '__match_args__': ('entity_ids', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.entity_get_all_child_uuids class method)

entity_get_child_uuid (class in kittycad.models.ok_modeling_cmd_response)

(entity_id=<kittycad.types.Unset object>, type='entity_get_child_uuid')

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_child_uuid', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `EntityGetChildUuid` command.', 'to_dict': <function entity_get_child_uuid.to_dict>, 'from_dict': <classmethod(<function entity_get_child_uuid.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_child_uuid.__getitem__>, '__setitem__': <function entity_get_child_uuid.__setitem__>, '__delitem__': <function entity_get_child_uuid.__delitem__>, '__contains__': <function entity_get_child_uuid.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_child_uuid' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_child_uuid' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_child_uuid', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_child_uuid.__repr__>, '__eq__': <function entity_get_child_uuid.__eq__>, '__ne__': <function entity_get_child_uuid.__ne__>, '__lt__': <function entity_get_child_uuid.__lt__>, '__le__': <function entity_get_child_uuid.__le__>, '__gt__': <function entity_get_child_uuid.__gt__>, '__ge__': <function entity_get_child_uuid.__ge__>, '__hash__': None, '__init__': <function entity_get_child_uuid.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

__ge__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

__gt__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

__le__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

__lt__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

__ne__() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid method)

from_dict() (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid class method)

type (kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid attribute)

entity_get_num_children (class in kittycad.models.ok_modeling_cmd_response)

(num=<kittycad.types.Unset object>, type='entity_get_num_children')

{'additional_properties': typing.Dict[str, typing.Any], 'num': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>}

(Attribute(name='num', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='num'), Attribute(name='type', default='entity_get_num_children', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'num': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `EntityGetNumChildren` command.', 'to_dict': <function entity_get_num_children.to_dict>, 'from_dict': <classmethod(<function entity_get_num_children.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_num_children.__getitem__>, '__setitem__': <function entity_get_num_children.__setitem__>, '__delitem__': <function entity_get_num_children.__delitem__>, '__contains__': <function entity_get_num_children.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_num_children' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_num_children' objects>, '__attrs_attrs__': (Attribute(name='num', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='num'), Attribute(name='type', default='entity_get_num_children', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_num_children.__repr__>, '__eq__': <function entity_get_num_children.__eq__>, '__ne__': <function entity_get_num_children.__ne__>, '__lt__': <function entity_get_num_children.__lt__>, '__le__': <function entity_get_num_children.__le__>, '__gt__': <function entity_get_num_children.__gt__>, '__ge__': <function entity_get_num_children.__ge__>, '__hash__': None, '__init__': <function entity_get_num_children.__init__>, '__match_args__': ('num', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.entity_get_num_children class method)

num (kittycad.models.ok_modeling_cmd_response.entity_get_num_children attribute)

entity_get_parent_id (class in kittycad.models.ok_modeling_cmd_response)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `EntityGetParentId` command.', 'to_dict': <function entity_get_parent_id.to_dict>, 'from_dict': <classmethod(<function entity_get_parent_id.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function entity_get_parent_id.__getitem__>, '__setitem__': <function entity_get_parent_id.__setitem__>, '__delitem__': <function entity_get_parent_id.__delitem__>, '__contains__': <function entity_get_parent_id.__contains__>, '__dict__': <attribute '__dict__' of 'entity_get_parent_id' objects>, '__weakref__': <attribute '__weakref__' of 'entity_get_parent_id' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='entity_get_parent_id', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function entity_get_parent_id.__repr__>, '__eq__': <function entity_get_parent_id.__eq__>, '__ne__': <function entity_get_parent_id.__ne__>, '__lt__': <function entity_get_parent_id.__lt__>, '__le__': <function entity_get_parent_id.__le__>, '__gt__': <function entity_get_parent_id.__gt__>, '__ge__': <function entity_get_parent_id.__ge__>, '__hash__': None, '__init__': <function entity_get_parent_id.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

__ge__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

__gt__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

__le__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

__lt__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

__ne__() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

from_dict() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id method)

type (kittycad.models.ok_modeling_cmd_response.entity_get_parent_id attribute)

The response from the `Export` command. When this is being performed over a websocket, this is sent as binary not JSON. The binary data can be deserialized as `bincode` into a `Vec<ExportFile>`.

 command. When this is being performed over a websocket, this is sent as binary not JSON. The binary data can be deserialized as 

export.ExportFile (class in kittycad.models.ok_modeling_cmd_response)

export.ExportFile(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__dict__ (kittycad.models.ok_modeling_cmd_response.export.ExportFile attribute)

__eq__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__ge__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__gt__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__hash__ (kittycad.models.ok_modeling_cmd_response.export.ExportFile attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

export.ExportFile.__init__(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__le__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__lt__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__ne__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__repr__() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

contents (kittycad.models.ok_modeling_cmd_response.export.ExportFile attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.export.ExportFile class method)

name (kittycad.models.ok_modeling_cmd_response.export.ExportFile attribute)

to_dict() (kittycad.models.ok_modeling_cmd_response.export.ExportFile method)

__annotations__ (kittycad.models.ok_modeling_cmd_response.export attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'files': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.export_file.ExportFile]], 'type': <class 'str'>}

__attrs_attrs__ (kittycad.models.ok_modeling_cmd_response.export attribute)

(Attribute(name='files', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.export_file.ExportFile]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='files'), Attribute(name='type', default='export', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ok_modeling_cmd_response.export method)

__delitem__() (kittycad.models.ok_modeling_cmd_response.export method)

__dict__ (kittycad.models.ok_modeling_cmd_response.export attribute)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'files': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.export_file.ExportFile]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Export` command. When this is being performed over a websocket, this is sent as binary not JSON. The binary data can be deserialized as `bincode` into a `Vec<ExportFile>`.', 'ExportFile': <class 'kittycad.models.export_file.ExportFile'>, 'to_dict': <function export.to_dict>, 'from_dict': <classmethod(<function export.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function export.__getitem__>, '__setitem__': <function export.__setitem__>, '__delitem__': <function export.__delitem__>, '__contains__': <function export.__contains__>, '__dict__': <attribute '__dict__' of 'export' objects>, '__weakref__': <attribute '__weakref__' of 'export' objects>, '__attrs_attrs__': (Attribute(name='files', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.export_file.ExportFile]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='files'), Attribute(name='type', default='export', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function export.__repr__>, '__eq__': <function export.__eq__>, '__ne__': <function export.__ne__>, '__lt__': <function export.__lt__>, '__le__': <function export.__le__>, '__gt__': <function export.__gt__>, '__ge__': <function export.__ge__>, '__hash__': None, '__init__': <function export.__init__>, '__match_args__': ('files', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.export method)

__ge__() (kittycad.models.ok_modeling_cmd_response.export method)

__getitem__() (kittycad.models.ok_modeling_cmd_response.export method)

__gt__() (kittycad.models.ok_modeling_cmd_response.export method)

__hash__ (kittycad.models.ok_modeling_cmd_response.export attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.export method)

export.__init__(files=<kittycad.types.Unset object>, type='export')

__le__() (kittycad.models.ok_modeling_cmd_response.export method)

__lt__() (kittycad.models.ok_modeling_cmd_response.export method)

__match_args__ (kittycad.models.ok_modeling_cmd_response.export attribute)

__module__ (kittycad.models.ok_modeling_cmd_response.export attribute)

__ne__() (kittycad.models.ok_modeling_cmd_response.export method)

__repr__() (kittycad.models.ok_modeling_cmd_response.export method)

__setitem__() (kittycad.models.ok_modeling_cmd_response.export method)

additional_keys (kittycad.models.ok_modeling_cmd_response.export property)

files (kittycad.models.ok_modeling_cmd_response.export attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.export class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.export method)

type (kittycad.models.ok_modeling_cmd_response.export attribute)

get_entity_type (class in kittycad.models.ok_modeling_cmd_response)

(entity_type=<kittycad.types.Unset object>, type='get_entity_type')

{'additional_properties': typing.Dict[str, typing.Any], 'entity_type': typing.Union[kittycad.types.Unset, kittycad.models.entity_type.EntityType], 'type': <class 'str'>}

(Attribute(name='entity_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.entity_type.EntityType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_type'), Attribute(name='type', default='get_entity_type', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__delitem__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__dict__ (kittycad.models.ok_modeling_cmd_response.get_entity_type attribute)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_type': typing.Union[kittycad.types.Unset, kittycad.models.entity_type.EntityType], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `GetEntityType` command.', 'to_dict': <function get_entity_type.to_dict>, 'from_dict': <classmethod(<function get_entity_type.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function get_entity_type.__getitem__>, '__setitem__': <function get_entity_type.__setitem__>, '__delitem__': <function get_entity_type.__delitem__>, '__contains__': <function get_entity_type.__contains__>, '__dict__': <attribute '__dict__' of 'get_entity_type' objects>, '__weakref__': <attribute '__weakref__' of 'get_entity_type' objects>, '__attrs_attrs__': (Attribute(name='entity_type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.entity_type.EntityType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_type'), Attribute(name='type', default='get_entity_type', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function get_entity_type.__repr__>, '__eq__': <function get_entity_type.__eq__>, '__ne__': <function get_entity_type.__ne__>, '__lt__': <function get_entity_type.__lt__>, '__le__': <function get_entity_type.__le__>, '__gt__': <function get_entity_type.__gt__>, '__ge__': <function get_entity_type.__ge__>, '__hash__': None, '__init__': <function get_entity_type.__init__>, '__match_args__': ('entity_type', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__ge__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__getitem__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__gt__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__hash__ (kittycad.models.ok_modeling_cmd_response.get_entity_type attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__le__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__lt__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__module__ (kittycad.models.ok_modeling_cmd_response.get_entity_type attribute)

__ne__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__repr__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

__setitem__() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

entity_type (kittycad.models.ok_modeling_cmd_response.get_entity_type attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.get_entity_type class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.get_entity_type method)

type (kittycad.models.ok_modeling_cmd_response.get_entity_type attribute)

highlight_set_entity (class in kittycad.models.ok_modeling_cmd_response)

highlight_set_entity(entity_id=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

(entity_id=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

{'additional_properties': typing.Dict[str, typing.Any], 'entity_id': typing.Union[kittycad.types.Unset, str], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>}

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='highlight_set_entity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'sequence': typing.Union[kittycad.types.Unset, int], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `HighlightSetEntity` command.', 'to_dict': <function highlight_set_entity.to_dict>, 'from_dict': <classmethod(<function highlight_set_entity.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function highlight_set_entity.__getitem__>, '__setitem__': <function highlight_set_entity.__setitem__>, '__delitem__': <function highlight_set_entity.__delitem__>, '__contains__': <function highlight_set_entity.__contains__>, '__dict__': <attribute '__dict__' of 'highlight_set_entity' objects>, '__weakref__': <attribute '__weakref__' of 'highlight_set_entity' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='sequence', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, int], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='sequence'), Attribute(name='type', default='highlight_set_entity', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function highlight_set_entity.__repr__>, '__eq__': <function highlight_set_entity.__eq__>, '__ne__': <function highlight_set_entity.__ne__>, '__lt__': <function highlight_set_entity.__lt__>, '__le__': <function highlight_set_entity.__le__>, '__gt__': <function highlight_set_entity.__gt__>, '__ge__': <function highlight_set_entity.__ge__>, '__hash__': None, '__init__': <function highlight_set_entity.__init__>, '__match_args__': ('entity_id', 'sequence', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

__ge__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

__gt__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

highlight_set_entity.__init__(entity_id=<kittycad.types.Unset object>, sequence=<kittycad.types.Unset object>, type='highlight_set_entity')

__le__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

__lt__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

__ne__() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

from_dict() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.highlight_set_entity method)

type (kittycad.models.ok_modeling_cmd_response.highlight_set_entity attribute)

select_get(entity_ids=<kittycad.types.Unset object>, type='select_get')

__annotations__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

__attrs_attrs__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

(Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='type', default='select_get', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__delitem__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__dict__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_ids': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `SelectGet` command.', 'to_dict': <function select_get.to_dict>, 'from_dict': <classmethod(<function select_get.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_get.__getitem__>, '__setitem__': <function select_get.__setitem__>, '__delitem__': <function select_get.__delitem__>, '__contains__': <function select_get.__contains__>, '__dict__': <attribute '__dict__' of 'select_get' objects>, '__weakref__': <attribute '__weakref__' of 'select_get' objects>, '__attrs_attrs__': (Attribute(name='entity_ids', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_ids'), Attribute(name='type', default='select_get', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_get.__repr__>, '__eq__': <function select_get.__eq__>, '__ne__': <function select_get.__ne__>, '__lt__': <function select_get.__lt__>, '__le__': <function select_get.__le__>, '__gt__': <function select_get.__gt__>, '__ge__': <function select_get.__ge__>, '__hash__': None, '__init__': <function select_get.__init__>, '__match_args__': ('entity_ids', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__ge__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__getitem__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__gt__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__hash__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.select_get method)

select_get.__init__(entity_ids=<kittycad.types.Unset object>, type='select_get')

__le__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__lt__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__match_args__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

__module__ (kittycad.models.ok_modeling_cmd_response.select_get attribute)

__ne__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__repr__() (kittycad.models.ok_modeling_cmd_response.select_get method)

__setitem__() (kittycad.models.ok_modeling_cmd_response.select_get method)

additional_keys (kittycad.models.ok_modeling_cmd_response.select_get property)

entity_ids (kittycad.models.ok_modeling_cmd_response.select_get attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.select_get class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.select_get method)

type (kittycad.models.ok_modeling_cmd_response.select_get attribute)

select_with_point (class in kittycad.models.ok_modeling_cmd_response)

(entity_id=<kittycad.types.Unset object>, type='select_with_point')

(Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='select_with_point', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.ok_modeling_cmd_response.select_with_point attribute)

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'entity_id': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `SelectWithPoint` command.', 'to_dict': <function select_with_point.to_dict>, 'from_dict': <classmethod(<function select_with_point.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function select_with_point.__getitem__>, '__setitem__': <function select_with_point.__setitem__>, '__delitem__': <function select_with_point.__delitem__>, '__contains__': <function select_with_point.__contains__>, '__dict__': <attribute '__dict__' of 'select_with_point' objects>, '__weakref__': <attribute '__weakref__' of 'select_with_point' objects>, '__attrs_attrs__': (Attribute(name='entity_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='entity_id'), Attribute(name='type', default='select_with_point', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function select_with_point.__repr__>, '__eq__': <function select_with_point.__eq__>, '__ne__': <function select_with_point.__ne__>, '__lt__': <function select_with_point.__lt__>, '__le__': <function select_with_point.__le__>, '__gt__': <function select_with_point.__gt__>, '__ge__': <function select_with_point.__ge__>, '__hash__': None, '__init__': <function select_with_point.__init__>, '__match_args__': ('entity_id', 'type')})

__eq__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__ge__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__gt__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__hash__ (kittycad.models.ok_modeling_cmd_response.select_with_point attribute)

__init__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__le__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__lt__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__ne__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

__repr__() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

entity_id (kittycad.models.ok_modeling_cmd_response.select_with_point attribute)

from_dict() (kittycad.models.ok_modeling_cmd_response.select_with_point class method)

to_dict() (kittycad.models.ok_modeling_cmd_response.select_with_point method)

type (kittycad.models.ok_modeling_cmd_response.select_with_point attribute)

solid3d_get_all_edge_faces (class in kittycad.models.ok_modeling_cmd_response)

(faces=<kittycad.types.Unset object>, type='solid3d_get_all_edge_faces')

{'additional_properties': typing.Dict[str, typing.Any], 'faces': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>}

(Attribute(name='faces', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='faces'), Attribute(name='type', default='solid3d_get_all_edge_faces', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'faces': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Solid3dGetAllEdgeFaces` command.', 'to_dict': <function solid3d_get_all_edge_faces.to_dict>, 'from_dict': <classmethod(<function solid3d_get_all_edge_faces.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_all_edge_faces.__getitem__>, '__setitem__': <function solid3d_get_all_edge_faces.__setitem__>, '__delitem__': <function solid3d_get_all_edge_faces.__delitem__>, '__contains__': <function solid3d_get_all_edge_faces.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_all_edge_faces' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_all_edge_faces' objects>, '__attrs_attrs__': (Attribute(name='faces', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='faces'), Attribute(name='type', default='solid3d_get_all_edge_faces', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_all_edge_faces.__repr__>, '__eq__': <function solid3d_get_all_edge_faces.__eq__>, '__ne__': <function solid3d_get_all_edge_faces.__ne__>, '__lt__': <function solid3d_get_all_edge_faces.__lt__>, '__le__': <function solid3d_get_all_edge_faces.__le__>, '__gt__': <function solid3d_get_all_edge_faces.__gt__>, '__ge__': <function solid3d_get_all_edge_faces.__ge__>, '__hash__': None, '__init__': <function solid3d_get_all_edge_faces.__init__>, '__match_args__': ('faces', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.solid3d_get_all_edge_faces class method)

solid3d_get_all_opposite_edges (class in kittycad.models.ok_modeling_cmd_response)

(edges=<kittycad.types.Unset object>, type='solid3d_get_all_opposite_edges')

{'additional_properties': typing.Dict[str, typing.Any], 'edges': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>}

(Attribute(name='edges', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edges'), Attribute(name='type', default='solid3d_get_all_opposite_edges', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'edges': typing.Union[kittycad.types.Unset, typing.List[str]], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Solid3dGetAllOppositeEdges` command.', 'to_dict': <function solid3d_get_all_opposite_edges.to_dict>, 'from_dict': <classmethod(<function solid3d_get_all_opposite_edges.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_all_opposite_edges.__getitem__>, '__setitem__': <function solid3d_get_all_opposite_edges.__setitem__>, '__delitem__': <function solid3d_get_all_opposite_edges.__delitem__>, '__contains__': <function solid3d_get_all_opposite_edges.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_all_opposite_edges' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_all_opposite_edges' objects>, '__attrs_attrs__': (Attribute(name='edges', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edges'), Attribute(name='type', default='solid3d_get_all_opposite_edges', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_all_opposite_edges.__repr__>, '__eq__': <function solid3d_get_all_opposite_edges.__eq__>, '__ne__': <function solid3d_get_all_opposite_edges.__ne__>, '__lt__': <function solid3d_get_all_opposite_edges.__lt__>, '__le__': <function solid3d_get_all_opposite_edges.__le__>, '__gt__': <function solid3d_get_all_opposite_edges.__gt__>, '__ge__': <function solid3d_get_all_opposite_edges.__ge__>, '__hash__': None, '__init__': <function solid3d_get_all_opposite_edges.__init__>, '__match_args__': ('edges', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.solid3d_get_all_opposite_edges class method)

solid3d_get_next_adjacent_edge (class in kittycad.models.ok_modeling_cmd_response)

(edge=<kittycad.types.Unset object>, type='solid3d_get_next_adjacent_edge')

{'additional_properties': typing.Dict[str, typing.Any], 'edge': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>}

(Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_next_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'edge': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Solid3dGetNextAdjacentEdge` command.', 'to_dict': <function solid3d_get_next_adjacent_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_next_adjacent_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_next_adjacent_edge.__getitem__>, '__setitem__': <function solid3d_get_next_adjacent_edge.__setitem__>, '__delitem__': <function solid3d_get_next_adjacent_edge.__delitem__>, '__contains__': <function solid3d_get_next_adjacent_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_next_adjacent_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_next_adjacent_edge' objects>, '__attrs_attrs__': (Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_next_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_next_adjacent_edge.__repr__>, '__eq__': <function solid3d_get_next_adjacent_edge.__eq__>, '__ne__': <function solid3d_get_next_adjacent_edge.__ne__>, '__lt__': <function solid3d_get_next_adjacent_edge.__lt__>, '__le__': <function solid3d_get_next_adjacent_edge.__le__>, '__gt__': <function solid3d_get_next_adjacent_edge.__gt__>, '__ge__': <function solid3d_get_next_adjacent_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_next_adjacent_edge.__init__>, '__match_args__': ('edge', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.solid3d_get_next_adjacent_edge class method)

solid3d_get_opposite_edge (class in kittycad.models.ok_modeling_cmd_response)

(edge=<kittycad.types.Unset object>, type='solid3d_get_opposite_edge')

(Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_opposite_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'edge': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Solid3dGetOppositeEdge` command.', 'to_dict': <function solid3d_get_opposite_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_opposite_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_opposite_edge.__getitem__>, '__setitem__': <function solid3d_get_opposite_edge.__setitem__>, '__delitem__': <function solid3d_get_opposite_edge.__delitem__>, '__contains__': <function solid3d_get_opposite_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_opposite_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_opposite_edge' objects>, '__attrs_attrs__': (Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_opposite_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_opposite_edge.__repr__>, '__eq__': <function solid3d_get_opposite_edge.__eq__>, '__ne__': <function solid3d_get_opposite_edge.__ne__>, '__lt__': <function solid3d_get_opposite_edge.__lt__>, '__le__': <function solid3d_get_opposite_edge.__le__>, '__gt__': <function solid3d_get_opposite_edge.__gt__>, '__ge__': <function solid3d_get_opposite_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_opposite_edge.__init__>, '__match_args__': ('edge', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.solid3d_get_opposite_edge class method)

solid3d_get_prev_adjacent_edge (class in kittycad.models.ok_modeling_cmd_response)

(edge=<kittycad.types.Unset object>, type='solid3d_get_prev_adjacent_edge')

(Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_prev_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.ok_modeling_cmd_response', '__annotations__': {'edge': typing.Union[kittycad.types.Unset, str], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `Solid3dGetPrevAdjacentEdge` command.', 'to_dict': <function solid3d_get_prev_adjacent_edge.to_dict>, 'from_dict': <classmethod(<function solid3d_get_prev_adjacent_edge.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function solid3d_get_prev_adjacent_edge.__getitem__>, '__setitem__': <function solid3d_get_prev_adjacent_edge.__setitem__>, '__delitem__': <function solid3d_get_prev_adjacent_edge.__delitem__>, '__contains__': <function solid3d_get_prev_adjacent_edge.__contains__>, '__dict__': <attribute '__dict__' of 'solid3d_get_prev_adjacent_edge' objects>, '__weakref__': <attribute '__weakref__' of 'solid3d_get_prev_adjacent_edge' objects>, '__attrs_attrs__': (Attribute(name='edge', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='edge'), Attribute(name='type', default='solid3d_get_prev_adjacent_edge', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function solid3d_get_prev_adjacent_edge.__repr__>, '__eq__': <function solid3d_get_prev_adjacent_edge.__eq__>, '__ne__': <function solid3d_get_prev_adjacent_edge.__ne__>, '__lt__': <function solid3d_get_prev_adjacent_edge.__lt__>, '__le__': <function solid3d_get_prev_adjacent_edge.__le__>, '__gt__': <function solid3d_get_prev_adjacent_edge.__gt__>, '__ge__': <function solid3d_get_prev_adjacent_edge.__ge__>, '__hash__': None, '__init__': <function solid3d_get_prev_adjacent_edge.__init__>, '__match_args__': ('edge', 'type')})

from_dict() (kittycad.models.ok_modeling_cmd_response.solid3d_get_prev_adjacent_edge class method)

Method generated by attrs for class empty.

rtype

TypeVar(YW, bound= empty)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.ok_modeling_cmd_response.empty.to_dict>`\ \(\)

__init__([entity_ids, type])

rtype

TypeVar(UA, bound= entity_get_all_child_uuids)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``UA``, bound= entity_get_all_child_uuids)

type

rtype

TypeVar(RG, bound= entity_get_child_uuid)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.entity_get_child_uuid.__init__>`\ \(\[entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``RG``, bound= entity_get_child_uuid)

__init__([num, type])

rtype

TypeVar(IT, bound= entity_get_num_children)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.entity_get_num_children.__init__>`\ \(\[num\, type\]\)

:py:class:`~typing.TypeVar`\(``IT``, bound= entity_get_num_children)

rtype

TypeVar(LD, bound= entity_get_parent_id)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.entity_get_parent_id.__init__>`\ \(\[entity\_id\, type\]\)

:py:class:`~typing.TypeVar`\(``LD``, bound= entity_get_parent_id)

__init__([files, type])

rtype

TypeVar(QX, bound= export)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.export.__init__>`\ \(\[files\, type\]\)

__init__([entity_type, type])

rtype

TypeVar(MZ, bound= get_entity_type)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.get_entity_type.__init__>`\ \(\[entity\_type\, type\]\)

entity_type

type

__init__([entity_id, sequence, type])

rtype

TypeVar(VX, bound= highlight_set_entity)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.highlight_set_entity.__init__>`\ \(\[entity\_id\, sequence\, type\]\)

:py:class:`~typing.TypeVar`\(``VX``, bound= highlight_set_entity)

entity_id

sequence

type

rtype

TypeVar(TN, bound= select_get)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.select_get.__init__>`\ \(\[entity\_ids\, type\]\)

rtype

TypeVar(NO, bound= select_with_point)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.select_with_point.__init__>`\ \(\[entity\_id\, type\]\)

__init__([faces, type])

rtype

TypeVar(UG, bound= solid3d_get_all_edge_faces)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.solid3d_get_all_edge_faces.__init__>`\ \(\[faces\, type\]\)

:py:class:`~typing.TypeVar`\(``UG``, bound= solid3d_get_all_edge_faces)

__init__([edges, type])

rtype

TypeVar(CY, bound= solid3d_get_all_opposite_edges)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``CY``, bound= solid3d_get_all_opposite_edges)

__init__([edge, type])

rtype

TypeVar(LO, bound= solid3d_get_next_adjacent_edge)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``LO``, bound= solid3d_get_next_adjacent_edge)

rtype

TypeVar(NZ, bound= solid3d_get_opposite_edge)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.ok_modeling_cmd_response.solid3d_get_opposite_edge.__init__>`\ \(\[edge\, type\]\)

:py:class:`~typing.TypeVar`\(``NZ``, bound= solid3d_get_opposite_edge)

rtype

TypeVar(LI, bound= solid3d_get_prev_adjacent_edge)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``LI``, bound= solid3d_get_prev_adjacent_edge)

:py:obj:`Onboarding <kittycad.models.onboarding.Onboarding>`\ \(\[...\]\)

Onboarding(first_call_from__their_machine_date=<kittycad.types.Unset object>, first_litterbox_execute_date=<kittycad.types.Unset object>, first_token_date=<kittycad.types.Unset object>)

(first_call_from__their_machine_date=<kittycad.types.Unset object>, first_litterbox_execute_date=<kittycad.types.Unset object>, first_token_date=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.onboarding.Onboarding attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'first_call_from__their_machine_date': typing.Union[kittycad.types.Unset, str], 'first_litterbox_execute_date': typing.Union[kittycad.types.Unset, str], 'first_token_date': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.onboarding.Onboarding attribute)

(Attribute(name='first_call_from__their_machine_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_call_from__their_machine_date'), Attribute(name='first_litterbox_execute_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_litterbox_execute_date'), Attribute(name='first_token_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_token_date'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.onboarding', '__annotations__': {'first_call_from__their_machine_date': typing.Union[kittycad.types.Unset, str], 'first_litterbox_execute_date': typing.Union[kittycad.types.Unset, str], 'first_token_date': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Onboarding details', 'to_dict': <function Onboarding.to_dict>, 'from_dict': <classmethod(<function Onboarding.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Onboarding.__getitem__>, '__setitem__': <function Onboarding.__setitem__>, '__delitem__': <function Onboarding.__delitem__>, '__contains__': <function Onboarding.__contains__>, '__dict__': <attribute '__dict__' of 'Onboarding' objects>, '__weakref__': <attribute '__weakref__' of 'Onboarding' objects>, '__attrs_attrs__': (Attribute(name='first_call_from__their_machine_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_call_from__their_machine_date'), Attribute(name='first_litterbox_execute_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_litterbox_execute_date'), Attribute(name='first_token_date', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_token_date'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Onboarding.__repr__>, '__eq__': <function Onboarding.__eq__>, '__ne__': <function Onboarding.__ne__>, '__lt__': <function Onboarding.__lt__>, '__le__': <function Onboarding.__le__>, '__gt__': <function Onboarding.__gt__>, '__ge__': <function Onboarding.__ge__>, '__hash__': None, '__init__': <function Onboarding.__init__>, '__match_args__': ('first_call_from__their_machine_date', 'first_litterbox_execute_date', 'first_token_date')})

Onboarding.__init__(first_call_from__their_machine_date=<kittycad.types.Unset object>, first_litterbox_execute_date=<kittycad.types.Unset object>, first_token_date=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.onboarding.Onboarding attribute)

additional_keys (kittycad.models.onboarding.Onboarding property)

additional_properties (kittycad.models.onboarding.Onboarding attribute)

first_litterbox_execute_date (kittycad.models.onboarding.Onboarding attribute)

first_token_date (kittycad.models.onboarding.Onboarding attribute)

from_dict() (kittycad.models.onboarding.Onboarding class method)

__init__([...])

Method generated by attrs for class Onboarding.

rtype

TypeVar(XJ, bound= Onboarding)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.onboarding.Onboarding.__init__>`\ \(\[...\]\)

:py:obj:`to_dict <kittycad.models.onboarding.Onboarding.to_dict>`\ \(\)

first_call_from__their_machine_date

first_litterbox_execute_date

first_token_date

:py:obj:`OutputFile <kittycad.models.output_file.OutputFile>`\ \(\[contents\, name\]\)

OutputFile(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.output_file.OutputFile attribute)

__attrs_attrs__ (kittycad.models.output_file.OutputFile attribute)

OutputFile.__init__(contents=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.output_file.OutputFile attribute)

additional_keys (kittycad.models.output_file.OutputFile property)

additional_properties (kittycad.models.output_file.OutputFile attribute)

from_dict() (kittycad.models.output_file.OutputFile class method)

Method generated by attrs for class OutputFile.

rtype

TypeVar(OW, bound= OutputFile)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_file.OutputFile.__init__>`\ \(\[contents\, name\]\)

:py:obj:`to_dict <kittycad.models.output_file.OutputFile.to_dict>`\ \(\)

gltf([storage, type])

glTF 2.0.

obj([coords, type])

ply([coords, storage, type])

step([coords, type])

stl([coords, storage, type])

:py:obj:`gltf <kittycad.models.output_format.gltf>`\ \(\[storage\, type\]\)

:py:obj:`obj <kittycad.models.output_format.obj>`\ \(\[coords\, type\]\)

:py:obj:`ply <kittycad.models.output_format.ply>`\ \(\[coords\, storage\, type\]\)

:py:obj:`step <kittycad.models.output_format.step>`\ \(\[coords\, type\]\)

:py:obj:`stl <kittycad.models.output_format.stl>`\ \(\[coords\, storage\, type\]\)

glTF 2.0. We refer to this as glTF since that is how our customers refer to it, although by default it will be in binary format and thus technically (glb). If you prefer ascii output, you can set that option for the export.

{'additional_properties': typing.Dict[str, typing.Any], 'storage': typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], 'type': <class 'str'>}

(Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='gltf', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.output_format', '__annotations__': {'storage': typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'glTF 2.0. We refer to this as glTF since that is how our customers refer to it, although by default it will be in binary format and thus technically (glb). If you prefer ascii output, you can set that option for the export.', 'to_dict': <function gltf.to_dict>, 'from_dict': <classmethod(<function gltf.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function gltf.__getitem__>, '__setitem__': <function gltf.__setitem__>, '__delitem__': <function gltf.__delitem__>, '__contains__': <function gltf.__contains__>, '__dict__': <attribute '__dict__' of 'gltf' objects>, '__weakref__': <attribute '__weakref__' of 'gltf' objects>, '__attrs_attrs__': (Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='gltf', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function gltf.__repr__>, '__eq__': <function gltf.__eq__>, '__ne__': <function gltf.__ne__>, '__lt__': <function gltf.__lt__>, '__le__': <function gltf.__le__>, '__gt__': <function gltf.__gt__>, '__ge__': <function gltf.__ge__>, '__hash__': None, '__init__': <function gltf.__init__>, '__match_args__': ('storage', 'type')})

gltf.__init__(storage=<kittycad.types.Unset object>, type='gltf')

additional_properties (kittycad.models.output_format.gltf attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>}

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='obj', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.output_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Wavefront OBJ format.', 'to_dict': <function obj.to_dict>, 'from_dict': <classmethod(<function obj.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function obj.__getitem__>, '__setitem__': <function obj.__setitem__>, '__delitem__': <function obj.__delitem__>, '__contains__': <function obj.__contains__>, '__dict__': <attribute '__dict__' of 'obj' objects>, '__weakref__': <attribute '__weakref__' of 'obj' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='obj', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function obj.__repr__>, '__eq__': <function obj.__eq__>, '__ne__': <function obj.__ne__>, '__lt__': <function obj.__lt__>, '__le__': <function obj.__le__>, '__gt__': <function obj.__gt__>, '__ge__': <function obj.__ge__>, '__hash__': None, '__init__': <function obj.__init__>, '__match_args__': ('coords', 'type')})

additional_properties (kittycad.models.output_format.obj attribute)

ply(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='ply')

(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='ply')

{'additional_properties': typing.Dict[str, typing.Any], 'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'storage': typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], 'type': <class 'str'>}

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='ply', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.output_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'storage': typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The PLY Polygon File Format.', 'to_dict': <function ply.to_dict>, 'from_dict': <classmethod(<function ply.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function ply.__getitem__>, '__setitem__': <function ply.__setitem__>, '__delitem__': <function ply.__delitem__>, '__contains__': <function ply.__contains__>, '__dict__': <attribute '__dict__' of 'ply' objects>, '__weakref__': <attribute '__weakref__' of 'ply' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='ply', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function ply.__repr__>, '__eq__': <function ply.__eq__>, '__ne__': <function ply.__ne__>, '__lt__': <function ply.__lt__>, '__le__': <function ply.__le__>, '__gt__': <function ply.__gt__>, '__ge__': <function ply.__ge__>, '__hash__': None, '__init__': <function ply.__init__>, '__match_args__': ('coords', 'storage', 'type')})

ply.__init__(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='ply')

additional_properties (kittycad.models.output_format.ply attribute)

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='step', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.output_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'ISO 10303-21 (STEP) format.', 'to_dict': <function step.to_dict>, 'from_dict': <classmethod(<function step.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function step.__getitem__>, '__setitem__': <function step.__setitem__>, '__delitem__': <function step.__delitem__>, '__contains__': <function step.__contains__>, '__dict__': <attribute '__dict__' of 'step' objects>, '__weakref__': <attribute '__weakref__' of 'step' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='type', default='step', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function step.__repr__>, '__eq__': <function step.__eq__>, '__ne__': <function step.__ne__>, '__lt__': <function step.__lt__>, '__le__': <function step.__le__>, '__gt__': <function step.__gt__>, '__ge__': <function step.__ge__>, '__hash__': None, '__init__': <function step.__init__>, '__match_args__': ('coords', 'type')})

step.__init__(coords=<kittycad.types.Unset object>, type='step')

additional_properties (kittycad.models.output_format.step attribute)

stl(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='stl')

(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='stl')

(Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='stl', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.output_format', '__annotations__': {'coords': typing.Union[kittycad.types.Unset, kittycad.models.system.System], 'storage': typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': '*ST**ereo**L**ithography format.', 'to_dict': <function stl.to_dict>, 'from_dict': <classmethod(<function stl.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function stl.__getitem__>, '__setitem__': <function stl.__setitem__>, '__delitem__': <function stl.__delitem__>, '__contains__': <function stl.__contains__>, '__dict__': <attribute '__dict__' of 'stl' objects>, '__weakref__': <attribute '__weakref__' of 'stl' objects>, '__attrs_attrs__': (Attribute(name='coords', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.system.System], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='coords'), Attribute(name='storage', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.storage.Storage], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='storage'), Attribute(name='type', default='stl', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function stl.__repr__>, '__eq__': <function stl.__eq__>, '__ne__': <function stl.__ne__>, '__lt__': <function stl.__lt__>, '__le__': <function stl.__le__>, '__gt__': <function stl.__gt__>, '__ge__': <function stl.__ge__>, '__hash__': None, '__init__': <function stl.__init__>, '__match_args__': ('coords', 'storage', 'type')})

stl.__init__(coords=<kittycad.types.Unset object>, storage=<kittycad.types.Unset object>, type='stl')

additional_properties (kittycad.models.output_format.stl attribute)

__init__([storage, type])

rtype

TypeVar(JQ, bound= gltf)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_format.gltf.__init__>`\ \(\[storage\, type\]\)

:py:obj:`to_dict <kittycad.models.output_format.gltf.to_dict>`\ \(\)

storage

type

__init__([coords, type])

rtype

TypeVar(PQ, bound= obj)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_format.obj.__init__>`\ \(\[coords\, type\]\)

:py:obj:`from_dict <kittycad.models.output_format.obj.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.output_format.obj.to_dict>`\ \(\)

coords

type

__init__([coords, storage, type])

rtype

TypeVar(IM, bound= ply)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_format.ply.__init__>`\ \(\[coords\, storage\, type\]\)

:py:obj:`from_dict <kittycad.models.output_format.ply.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.output_format.ply.to_dict>`\ \(\)

coords

storage

type

rtype

TypeVar(OU, bound= step)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_format.step.__init__>`\ \(\[coords\, type\]\)

:py:obj:`to_dict <kittycad.models.output_format.step.to_dict>`\ \(\)

rtype

TypeVar(KL, bound= stl)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.output_format.stl.__init__>`\ \(\[coords\, storage\, type\]\)

:py:obj:`from_dict <kittycad.models.output_format.stl.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.output_format.stl.to_dict>`\ \(\)

arc([angle_end, angle_start, center, ...])

A circular arc segment.

bezier([control1, control2, end, type])

A cubic bezier curve segment.

line([end, type])

A straight line segment.

:py:obj:`arc <kittycad.models.path_segment.arc>`\ \(\[angle\_end\, angle\_start\, center\, ...\]\)

:py:obj:`bezier <kittycad.models.path_segment.bezier>`\ \(\[control1\, control2\, end\, type\]\)

:py:obj:`line <kittycad.models.path_segment.line>`\ \(\[end\, type\]\)

arc(angle_end=<kittycad.types.Unset object>, angle_start=<kittycad.types.Unset object>, center=<kittycad.types.Unset object>, radius=<kittycad.types.Unset object>, type='arc')

(angle_end=<kittycad.types.Unset object>, angle_start=<kittycad.types.Unset object>, center=<kittycad.types.Unset object>, radius=<kittycad.types.Unset object>, type='arc')

{'additional_properties': typing.Dict[str, typing.Any], 'angle_end': typing.Union[kittycad.types.Unset, float], 'angle_start': typing.Union[kittycad.types.Unset, float], 'center': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'radius': typing.Union[kittycad.types.Unset, float], 'type': <class 'str'>}

(Attribute(name='angle_end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='angle_end'), Attribute(name='angle_start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='angle_start'), Attribute(name='center', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center'), Attribute(name='radius', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='radius'), Attribute(name='type', default='arc', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.path_segment', '__annotations__': {'angle_end': typing.Union[kittycad.types.Unset, float], 'angle_start': typing.Union[kittycad.types.Unset, float], 'center': typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], 'radius': typing.Union[kittycad.types.Unset, float], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A circular arc segment.', 'to_dict': <function arc.to_dict>, 'from_dict': <classmethod(<function arc.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function arc.__getitem__>, '__setitem__': <function arc.__setitem__>, '__delitem__': <function arc.__delitem__>, '__contains__': <function arc.__contains__>, '__dict__': <attribute '__dict__' of 'arc' objects>, '__weakref__': <attribute '__weakref__' of 'arc' objects>, '__attrs_attrs__': (Attribute(name='angle_end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='angle_end'), Attribute(name='angle_start', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='angle_start'), Attribute(name='center', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point2d.Point2d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='center'), Attribute(name='radius', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='radius'), Attribute(name='type', default='arc', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function arc.__repr__>, '__eq__': <function arc.__eq__>, '__ne__': <function arc.__ne__>, '__lt__': <function arc.__lt__>, '__le__': <function arc.__le__>, '__gt__': <function arc.__gt__>, '__ge__': <function arc.__ge__>, '__hash__': None, '__init__': <function arc.__init__>, '__match_args__': ('angle_end', 'angle_start', 'center', 'radius', 'type')})

arc.__init__(angle_end=<kittycad.types.Unset object>, angle_start=<kittycad.types.Unset object>, center=<kittycad.types.Unset object>, radius=<kittycad.types.Unset object>, type='arc')

additional_properties (kittycad.models.path_segment.arc attribute)

bezier(control1=<kittycad.types.Unset object>, control2=<kittycad.types.Unset object>, end=<kittycad.types.Unset object>, type='bezier')

(control1=<kittycad.types.Unset object>, control2=<kittycad.types.Unset object>, end=<kittycad.types.Unset object>, type='bezier')

A cubic bezier curve segment. Start at the end of the current line, go through control point 1 and 2, then end at a given point.

{'additional_properties': typing.Dict[str, typing.Any], 'control1': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'control2': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'end': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>}

(Attribute(name='control1', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='control1'), Attribute(name='control2', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='control2'), Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='type', default='bezier', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.path_segment', '__annotations__': {'control1': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'control2': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'end': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A cubic bezier curve segment. Start at the end of the current line, go through control point 1 and 2, then end at a given point.', 'to_dict': <function bezier.to_dict>, 'from_dict': <classmethod(<function bezier.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function bezier.__getitem__>, '__setitem__': <function bezier.__setitem__>, '__delitem__': <function bezier.__delitem__>, '__contains__': <function bezier.__contains__>, '__dict__': <attribute '__dict__' of 'bezier' objects>, '__weakref__': <attribute '__weakref__' of 'bezier' objects>, '__attrs_attrs__': (Attribute(name='control1', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='control1'), Attribute(name='control2', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='control2'), Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='type', default='bezier', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function bezier.__repr__>, '__eq__': <function bezier.__eq__>, '__ne__': <function bezier.__ne__>, '__lt__': <function bezier.__lt__>, '__le__': <function bezier.__le__>, '__gt__': <function bezier.__gt__>, '__ge__': <function bezier.__ge__>, '__hash__': None, '__init__': <function bezier.__init__>, '__match_args__': ('control1', 'control2', 'end', 'type')})

bezier.__init__(control1=<kittycad.types.Unset object>, control2=<kittycad.types.Unset object>, end=<kittycad.types.Unset object>, type='bezier')

additional_properties (kittycad.models.path_segment.bezier attribute)

A straight line segment. Goes from the current path "pen" to the given endpoint.

A straight line segment. Goes from the current path “pen” to the given endpoint.

{'additional_properties': typing.Dict[str, typing.Any], 'end': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>}

(Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='type', default='line', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.path_segment', '__annotations__': {'end': typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], 'type': <class 'str'>, 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A straight line segment. Goes from the current path "pen" to the given endpoint.', 'to_dict': <function line.to_dict>, 'from_dict': <classmethod(<function line.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function line.__getitem__>, '__setitem__': <function line.__setitem__>, '__delitem__': <function line.__delitem__>, '__contains__': <function line.__contains__>, '__dict__': <attribute '__dict__' of 'line' objects>, '__weakref__': <attribute '__weakref__' of 'line' objects>, '__attrs_attrs__': (Attribute(name='end', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.point3d.Point3d], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='end'), Attribute(name='type', default='line', validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'str'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function line.__repr__>, '__eq__': <function line.__eq__>, '__ne__': <function line.__ne__>, '__lt__': <function line.__lt__>, '__le__': <function line.__le__>, '__gt__': <function line.__gt__>, '__ge__': <function line.__ge__>, '__hash__': None, '__init__': <function line.__init__>, '__match_args__': ('end', 'type')})

additional_properties (kittycad.models.path_segment.line attribute)

__init__([angle_end, angle_start, center, ...])

Method generated by attrs for class arc.

rtype

TypeVar(PO, bound= arc)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.path_segment.arc.__init__>`\ \(\[angle\_end\, angle\_start\, center\, ...\]\)

:py:obj:`from_dict <kittycad.models.path_segment.arc.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.path_segment.arc.to_dict>`\ \(\)

angle_end

angle_start

center

radius

type

__init__([control1, control2, end, type])

Method generated by attrs for class bezier.

rtype

TypeVar(PS, bound= bezier)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.path_segment.bezier.__init__>`\ \(\[control1\, control2\, end\, type\]\)

:py:obj:`to_dict <kittycad.models.path_segment.bezier.to_dict>`\ \(\)

control1

control2

end

type

__init__([end, type])

Method generated by attrs for class line.

rtype

TypeVar(XI, bound= line)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.path_segment.line.__init__>`\ \(\[end\, type\]\)

:py:obj:`from_dict <kittycad.models.path_segment.line.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.path_segment.line.to_dict>`\ \(\)

__annotations__ (kittycad.models.payment_intent.PaymentIntent attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'client_secret': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.payment_intent.PaymentIntent attribute)

(Attribute(name='client_secret', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_secret'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.payment_intent.PaymentIntent method)

__delitem__() (kittycad.models.payment_intent.PaymentIntent method)

__dict__ (kittycad.models.payment_intent.PaymentIntent attribute)

mappingproxy({'__module__': 'kittycad.models.payment_intent', '__annotations__': {'client_secret': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A payment intent response.', 'to_dict': <function PaymentIntent.to_dict>, 'from_dict': <classmethod(<function PaymentIntent.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function PaymentIntent.__getitem__>, '__setitem__': <function PaymentIntent.__setitem__>, '__delitem__': <function PaymentIntent.__delitem__>, '__contains__': <function PaymentIntent.__contains__>, '__dict__': <attribute '__dict__' of 'PaymentIntent' objects>, '__weakref__': <attribute '__weakref__' of 'PaymentIntent' objects>, '__attrs_attrs__': (Attribute(name='client_secret', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='client_secret'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function PaymentIntent.__repr__>, '__eq__': <function PaymentIntent.__eq__>, '__ne__': <function PaymentIntent.__ne__>, '__lt__': <function PaymentIntent.__lt__>, '__le__': <function PaymentIntent.__le__>, '__gt__': <function PaymentIntent.__gt__>, '__ge__': <function PaymentIntent.__ge__>, '__hash__': None, '__init__': <function PaymentIntent.__init__>, '__match_args__': ('client_secret',)})

__getitem__() (kittycad.models.payment_intent.PaymentIntent method)

__hash__ (kittycad.models.payment_intent.PaymentIntent attribute)

__init__() (kittycad.models.payment_intent.PaymentIntent method)

__match_args__ (kittycad.models.payment_intent.PaymentIntent attribute)

__module__ (kittycad.models.payment_intent.PaymentIntent attribute)

__repr__() (kittycad.models.payment_intent.PaymentIntent method)

__setitem__() (kittycad.models.payment_intent.PaymentIntent method)

additional_keys (kittycad.models.payment_intent.PaymentIntent property)

additional_properties (kittycad.models.payment_intent.PaymentIntent attribute)

client_secret (kittycad.models.payment_intent.PaymentIntent attribute)

from_dict() (kittycad.models.payment_intent.PaymentIntent class method)

__init__([client_secret])

Method generated by attrs for class PaymentIntent.

rtype

TypeVar(WR, bound= PaymentIntent)

to_dict()

rtype

:py:obj:`to_dict <kittycad.models.payment_intent.PaymentIntent.to_dict>`\ \(\)

:py:obj:`PaymentMethod <kittycad.models.payment_method.PaymentMethod>`\ \(\[billing\_info\, card\, ...\]\)

PaymentMethod(billing_info=<kittycad.types.Unset object>, card=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

(billing_info=<kittycad.types.Unset object>, card=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.payment_method.PaymentMethod attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'billing_info': typing.Union[kittycad.types.Unset, kittycad.models.billing_info.BillingInfo], 'card': typing.Union[kittycad.types.Unset, kittycad.models.card_details.CardDetails], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'type': typing.Union[kittycad.types.Unset, kittycad.models.payment_method_type.PaymentMethodType]}

__attrs_attrs__ (kittycad.models.payment_method.PaymentMethod attribute)

(Attribute(name='billing_info', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.billing_info.BillingInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='billing_info'), Attribute(name='card', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.card_details.CardDetails], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='card'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.payment_method_type.PaymentMethodType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.payment_method.PaymentMethod method)

__delitem__() (kittycad.models.payment_method.PaymentMethod method)

__dict__ (kittycad.models.payment_method.PaymentMethod attribute)

mappingproxy({'__module__': 'kittycad.models.payment_method', '__annotations__': {'billing_info': typing.Union[kittycad.types.Unset, kittycad.models.billing_info.BillingInfo], 'card': typing.Union[kittycad.types.Unset, kittycad.models.card_details.CardDetails], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'metadata': typing.Union[kittycad.types.Unset, typing.Any], 'type': typing.Union[kittycad.types.Unset, kittycad.models.payment_method_type.PaymentMethodType], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A payment method.', 'to_dict': <function PaymentMethod.to_dict>, 'from_dict': <classmethod(<function PaymentMethod.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function PaymentMethod.__getitem__>, '__setitem__': <function PaymentMethod.__setitem__>, '__delitem__': <function PaymentMethod.__delitem__>, '__contains__': <function PaymentMethod.__contains__>, '__dict__': <attribute '__dict__' of 'PaymentMethod' objects>, '__weakref__': <attribute '__weakref__' of 'PaymentMethod' objects>, '__attrs_attrs__': (Attribute(name='billing_info', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.billing_info.BillingInfo], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='billing_info'), Attribute(name='card', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.card_details.CardDetails], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='card'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='metadata', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='metadata'), Attribute(name='type', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.payment_method_type.PaymentMethodType], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='type'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function PaymentMethod.__repr__>, '__eq__': <function PaymentMethod.__eq__>, '__ne__': <function PaymentMethod.__ne__>, '__lt__': <function PaymentMethod.__lt__>, '__le__': <function PaymentMethod.__le__>, '__gt__': <function PaymentMethod.__gt__>, '__ge__': <function PaymentMethod.__ge__>, '__hash__': None, '__init__': <function PaymentMethod.__init__>, '__match_args__': ('billing_info', 'card', 'created_at', 'id', 'metadata', 'type')})

__getitem__() (kittycad.models.payment_method.PaymentMethod method)

__hash__ (kittycad.models.payment_method.PaymentMethod attribute)

__init__() (kittycad.models.payment_method.PaymentMethod method)

PaymentMethod.__init__(billing_info=<kittycad.types.Unset object>, card=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, metadata=<kittycad.types.Unset object>, type=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.payment_method.PaymentMethod attribute)

('billing_info', 'card', 'created_at', 'id', 'metadata', 'type')

__module__ (kittycad.models.payment_method.PaymentMethod attribute)

__repr__() (kittycad.models.payment_method.PaymentMethod method)

__setitem__() (kittycad.models.payment_method.PaymentMethod method)

additional_keys (kittycad.models.payment_method.PaymentMethod property)

additional_properties (kittycad.models.payment_method.PaymentMethod attribute)

billing_info (kittycad.models.payment_method.PaymentMethod attribute)

created_at (kittycad.models.payment_method.PaymentMethod attribute)

from_dict() (kittycad.models.payment_method.PaymentMethod class method)

metadata (kittycad.models.payment_method.PaymentMethod attribute)

__init__([billing_info, card, created_at, ...])

Method generated by attrs for class PaymentMethod.

rtype

TypeVar(XL, bound= PaymentMethod)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.payment_method.PaymentMethod.__init__>`\ \(\[billing\_info\, card\, created\_at\, ...\]\)

:py:obj:`to_dict <kittycad.models.payment_method.PaymentMethod.to_dict>`\ \(\)

billing_info

card

id

metadata

type

PaymentMethodCardChecks (class in kittycad.models.payment_method_card_checks)

PaymentMethodCardChecks(address_line1_check=<kittycad.types.Unset object>, address_postal_code_check=<kittycad.types.Unset object>, cvc_check=<kittycad.types.Unset object>)

(address_line1_check=<kittycad.types.Unset object>, address_postal_code_check=<kittycad.types.Unset object>, cvc_check=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'address_line1_check': typing.Union[kittycad.types.Unset, str], 'address_postal_code_check': typing.Union[kittycad.types.Unset, str], 'cvc_check': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='address_line1_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address_line1_check'), Attribute(name='address_postal_code_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address_postal_code_check'), Attribute(name='cvc_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cvc_check'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.payment_method_card_checks', '__annotations__': {'address_line1_check': typing.Union[kittycad.types.Unset, str], 'address_postal_code_check': typing.Union[kittycad.types.Unset, str], 'cvc_check': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Card checks.', 'to_dict': <function PaymentMethodCardChecks.to_dict>, 'from_dict': <classmethod(<function PaymentMethodCardChecks.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function PaymentMethodCardChecks.__getitem__>, '__setitem__': <function PaymentMethodCardChecks.__setitem__>, '__delitem__': <function PaymentMethodCardChecks.__delitem__>, '__contains__': <function PaymentMethodCardChecks.__contains__>, '__dict__': <attribute '__dict__' of 'PaymentMethodCardChecks' objects>, '__weakref__': <attribute '__weakref__' of 'PaymentMethodCardChecks' objects>, '__attrs_attrs__': (Attribute(name='address_line1_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address_line1_check'), Attribute(name='address_postal_code_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='address_postal_code_check'), Attribute(name='cvc_check', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='cvc_check'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function PaymentMethodCardChecks.__repr__>, '__eq__': <function PaymentMethodCardChecks.__eq__>, '__ne__': <function PaymentMethodCardChecks.__ne__>, '__lt__': <function PaymentMethodCardChecks.__lt__>, '__le__': <function PaymentMethodCardChecks.__le__>, '__gt__': <function PaymentMethodCardChecks.__gt__>, '__ge__': <function PaymentMethodCardChecks.__ge__>, '__hash__': None, '__init__': <function PaymentMethodCardChecks.__init__>, '__match_args__': ('address_line1_check', 'address_postal_code_check', 'cvc_check')})

PaymentMethodCardChecks.__init__(address_line1_check=<kittycad.types.Unset object>, address_postal_code_check=<kittycad.types.Unset object>, cvc_check=<kittycad.types.Unset object>)

('address_line1_check', 'address_postal_code_check', 'cvc_check')

from_dict() (kittycad.models.payment_method_card_checks.PaymentMethodCardChecks class method)

__init__([address_line1_check, ...])

Method generated by attrs for class PaymentMethodCardChecks.

rtype

TypeVar(ZX, bound= PaymentMethodCardChecks)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``ZX``, bound= PaymentMethodCardChecks)

address_line1_check

address_postal_code_check

cvc_check

PaymentMethodType(value[, names, module, ...])

An enum representing the possible values of an PaymentMethod's type field.

:py:obj:`PaymentMethodType <kittycad.models.payment_method_type.PaymentMethodType>`\ \(value\[\, names\, module\, ...\]\)

An enum representing the possible values of an `PaymentMethod`'s `type` field.

PaymentMethodType (class in kittycad.models.payment_method_type)

PaymentMethodType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

CARD (kittycad.models.payment_method_type.PaymentMethodType attribute)

__add__() (kittycad.models.payment_method_type.PaymentMethodType method)

__contains__() (kittycad.models.payment_method_type.PaymentMethodType method)

__dict__ (kittycad.models.payment_method_type.PaymentMethodType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.payment_method_type', '__doc__': "An enum representing the possible values of an `PaymentMethod`'s `type` field.", '__str__': <function PaymentMethodType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CARD'], '_member_map_': {'CARD': <PaymentMethodType.CARD: 'card'>}, '_value2member_map_': {'card': <PaymentMethodType.CARD: 'card'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'PaymentMethodType' objects>, '__weakref__': <attribute '__weakref__' of 'PaymentMethodType' objects>, 'CARD': <PaymentMethodType.CARD: 'card'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.payment_method_type.PaymentMethodType method)

__eq__() (kittycad.models.payment_method_type.PaymentMethodType method)

__format__() (kittycad.models.payment_method_type.PaymentMethodType method)

__ge__() (kittycad.models.payment_method_type.PaymentMethodType method)

__getitem__() (kittycad.models.payment_method_type.PaymentMethodType method)

__getnewargs__() (kittycad.models.payment_method_type.PaymentMethodType method)

__gt__() (kittycad.models.payment_method_type.PaymentMethodType method)

__hash__() (kittycad.models.payment_method_type.PaymentMethodType method)

__init__() (kittycad.models.payment_method_type.PaymentMethodType method)

__iter__() (kittycad.models.payment_method_type.PaymentMethodType method)

__le__() (kittycad.models.payment_method_type.PaymentMethodType method)

__len__() (kittycad.models.payment_method_type.PaymentMethodType method)

__lt__() (kittycad.models.payment_method_type.PaymentMethodType method)

__mod__() (kittycad.models.payment_method_type.PaymentMethodType method)

__module__ (kittycad.models.payment_method_type.PaymentMethodType attribute)

__mul__() (kittycad.models.payment_method_type.PaymentMethodType method)

__ne__() (kittycad.models.payment_method_type.PaymentMethodType method)

__new__() (kittycad.models.payment_method_type.PaymentMethodType method)

__reduce_ex__() (kittycad.models.payment_method_type.PaymentMethodType method)

__repr__() (kittycad.models.payment_method_type.PaymentMethodType method)

__rmod__() (kittycad.models.payment_method_type.PaymentMethodType method)

__rmul__() (kittycad.models.payment_method_type.PaymentMethodType method)

__sizeof__() (kittycad.models.payment_method_type.PaymentMethodType method)

__str__() (kittycad.models.payment_method_type.PaymentMethodType method)

PaymentMethodType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.payment_method_type.PaymentMethodType attribute)

_member_names_ (kittycad.models.payment_method_type.PaymentMethodType attribute)

_member_type_ (kittycad.models.payment_method_type.PaymentMethodType attribute)

_new_member_() (kittycad.models.payment_method_type.PaymentMethodType method)

_use_args_ (kittycad.models.payment_method_type.PaymentMethodType attribute)

_value_repr_() (kittycad.models.payment_method_type.PaymentMethodType method)

capitalize() (kittycad.models.payment_method_type.PaymentMethodType method)

casefold() (kittycad.models.payment_method_type.PaymentMethodType method)

center() (kittycad.models.payment_method_type.PaymentMethodType method)

count() (kittycad.models.payment_method_type.PaymentMethodType method)

encode() (kittycad.models.payment_method_type.PaymentMethodType method)

endswith() (kittycad.models.payment_method_type.PaymentMethodType method)

expandtabs() (kittycad.models.payment_method_type.PaymentMethodType method)

find() (kittycad.models.payment_method_type.PaymentMethodType method)

format() (kittycad.models.payment_method_type.PaymentMethodType method)

format_map() (kittycad.models.payment_method_type.PaymentMethodType method)

index() (kittycad.models.payment_method_type.PaymentMethodType method)

isalnum() (kittycad.models.payment_method_type.PaymentMethodType method)

isalpha() (kittycad.models.payment_method_type.PaymentMethodType method)

isascii() (kittycad.models.payment_method_type.PaymentMethodType method)

isdecimal() (kittycad.models.payment_method_type.PaymentMethodType method)

isdigit() (kittycad.models.payment_method_type.PaymentMethodType method)

isidentifier() (kittycad.models.payment_method_type.PaymentMethodType method)

islower() (kittycad.models.payment_method_type.PaymentMethodType method)

isnumeric() (kittycad.models.payment_method_type.PaymentMethodType method)

isprintable() (kittycad.models.payment_method_type.PaymentMethodType method)

isspace() (kittycad.models.payment_method_type.PaymentMethodType method)

istitle() (kittycad.models.payment_method_type.PaymentMethodType method)

isupper() (kittycad.models.payment_method_type.PaymentMethodType method)

join() (kittycad.models.payment_method_type.PaymentMethodType method)

ljust() (kittycad.models.payment_method_type.PaymentMethodType method)

lower() (kittycad.models.payment_method_type.PaymentMethodType method)

lstrip() (kittycad.models.payment_method_type.PaymentMethodType method)

maketrans() (kittycad.models.payment_method_type.PaymentMethodType static method)

partition() (kittycad.models.payment_method_type.PaymentMethodType method)

removeprefix() (kittycad.models.payment_method_type.PaymentMethodType method)

removesuffix() (kittycad.models.payment_method_type.PaymentMethodType method)

replace() (kittycad.models.payment_method_type.PaymentMethodType method)

rfind() (kittycad.models.payment_method_type.PaymentMethodType method)

rindex() (kittycad.models.payment_method_type.PaymentMethodType method)

rjust() (kittycad.models.payment_method_type.PaymentMethodType method)

rpartition() (kittycad.models.payment_method_type.PaymentMethodType method)

rsplit() (kittycad.models.payment_method_type.PaymentMethodType method)

rstrip() (kittycad.models.payment_method_type.PaymentMethodType method)

split() (kittycad.models.payment_method_type.PaymentMethodType method)

splitlines() (kittycad.models.payment_method_type.PaymentMethodType method)

startswith() (kittycad.models.payment_method_type.PaymentMethodType method)

strip() (kittycad.models.payment_method_type.PaymentMethodType method)

swapcase() (kittycad.models.payment_method_type.PaymentMethodType method)

title() (kittycad.models.payment_method_type.PaymentMethodType method)

translate() (kittycad.models.payment_method_type.PaymentMethodType method)

upper() (kittycad.models.payment_method_type.PaymentMethodType method)

zfill() (kittycad.models.payment_method_type.PaymentMethodType method)

:py:obj:`__init__ <kittycad.models.payment_method_type.PaymentMethodType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.payment_method_type.PaymentMethodType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.payment_method_type.PaymentMethodType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.payment_method_type.PaymentMethodType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.payment_method_type.PaymentMethodType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.payment_method_type.PaymentMethodType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.payment_method_type.PaymentMethodType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.payment_method_type.PaymentMethodType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.payment_method_type.PaymentMethodType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.payment_method_type.PaymentMethodType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.payment_method_type.PaymentMethodType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.payment_method_type.PaymentMethodType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.payment_method_type.PaymentMethodType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.payment_method_type.PaymentMethodType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.payment_method_type.PaymentMethodType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.payment_method_type.PaymentMethodType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.payment_method_type.PaymentMethodType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.payment_method_type.PaymentMethodType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.payment_method_type.PaymentMethodType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.payment_method_type.PaymentMethodType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.payment_method_type.PaymentMethodType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.payment_method_type.PaymentMethodType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.payment_method_type.PaymentMethodType.zfill>`\ \(width\, \/\)

PluginsInfo([authorization, log, network, ...])

Available plugins per type.

:py:obj:`PluginsInfo <kittycad.models.plugins_info.PluginsInfo>`\ \(\[authorization\, log\, network\, ...\]\)

PluginsInfo(authorization=<kittycad.types.Unset object>, log=<kittycad.types.Unset object>, network=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

(authorization=<kittycad.types.Unset object>, log=<kittycad.types.Unset object>, network=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

**Note**: Only unmanaged (V1) plugins are included in this list. V1 plugins are "lazily" loaded, and are not returned in this list if there is no resource using the plugin.

: Only unmanaged (V1) plugins are included in this list. V1 plugins are “lazily” loaded, and are not returned in this list if there is no resource using the plugin.

__annotations__ (kittycad.models.plugins_info.PluginsInfo attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'authorization': typing.Union[kittycad.types.Unset, typing.List[str]], 'log': typing.Union[kittycad.types.Unset, typing.List[str]], 'network': typing.Union[kittycad.types.Unset, typing.List[str]], 'volume': typing.Union[kittycad.types.Unset, typing.List[str]]}

__attrs_attrs__ (kittycad.models.plugins_info.PluginsInfo attribute)

(Attribute(name='authorization', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='authorization'), Attribute(name='log', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='log'), Attribute(name='network', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='network'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.plugins_info.PluginsInfo method)

mappingproxy({'__module__': 'kittycad.models.plugins_info', '__annotations__': {'authorization': typing.Union[kittycad.types.Unset, typing.List[str]], 'log': typing.Union[kittycad.types.Unset, typing.List[str]], 'network': typing.Union[kittycad.types.Unset, typing.List[str]], 'volume': typing.Union[kittycad.types.Unset, typing.List[str]], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Available plugins per type.\n\n    **Note**: Only unmanaged (V1) plugins are included in this list. V1 plugins are "lazily" loaded, and are not returned in this list if there is no resource using the plugin.\n    ', 'to_dict': <function PluginsInfo.to_dict>, 'from_dict': <classmethod(<function PluginsInfo.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function PluginsInfo.__getitem__>, '__setitem__': <function PluginsInfo.__setitem__>, '__delitem__': <function PluginsInfo.__delitem__>, '__contains__': <function PluginsInfo.__contains__>, '__dict__': <attribute '__dict__' of 'PluginsInfo' objects>, '__weakref__': <attribute '__weakref__' of 'PluginsInfo' objects>, '__attrs_attrs__': (Attribute(name='authorization', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='authorization'), Attribute(name='log', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='log'), Attribute(name='network', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='network'), Attribute(name='volume', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='volume'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function PluginsInfo.__repr__>, '__eq__': <function PluginsInfo.__eq__>, '__ne__': <function PluginsInfo.__ne__>, '__lt__': <function PluginsInfo.__lt__>, '__le__': <function PluginsInfo.__le__>, '__gt__': <function PluginsInfo.__gt__>, '__ge__': <function PluginsInfo.__ge__>, '__hash__': None, '__init__': <function PluginsInfo.__init__>, '__match_args__': ('authorization', 'log', 'network', 'volume')})

PluginsInfo.__init__(authorization=<kittycad.types.Unset object>, log=<kittycad.types.Unset object>, network=<kittycad.types.Unset object>, volume=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.plugins_info.PluginsInfo attribute)

additional_keys (kittycad.models.plugins_info.PluginsInfo property)

additional_properties (kittycad.models.plugins_info.PluginsInfo attribute)

authorization (kittycad.models.plugins_info.PluginsInfo attribute)

from_dict() (kittycad.models.plugins_info.PluginsInfo class method)

__init__([authorization, log, network, volume])

Method generated by attrs for class PluginsInfo.

rtype

TypeVar(FT, bound= PluginsInfo)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.plugins_info.PluginsInfo.__init__>`\ \(\[authorization\, log\, network\, volume\]\)

:py:obj:`to_dict <kittycad.models.plugins_info.PluginsInfo.to_dict>`\ \(\)

authorization

log

network

volume

:py:obj:`Point2d <kittycad.models.point2d.Point2d>`\ \(\[x\, y\]\)

Point2d(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'x': typing.Union[kittycad.types.Unset, float], 'y': typing.Union[kittycad.types.Unset, float]}

(Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.point2d', '__annotations__': {'x': typing.Union[kittycad.types.Unset, float], 'y': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A point in 2D space', 'to_dict': <function Point2d.to_dict>, 'from_dict': <classmethod(<function Point2d.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Point2d.__getitem__>, '__setitem__': <function Point2d.__setitem__>, '__delitem__': <function Point2d.__delitem__>, '__contains__': <function Point2d.__contains__>, '__dict__': <attribute '__dict__' of 'Point2d' objects>, '__weakref__': <attribute '__weakref__' of 'Point2d' objects>, '__attrs_attrs__': (Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Point2d.__repr__>, '__eq__': <function Point2d.__eq__>, '__ne__': <function Point2d.__ne__>, '__lt__': <function Point2d.__lt__>, '__le__': <function Point2d.__le__>, '__gt__': <function Point2d.__gt__>, '__ge__': <function Point2d.__ge__>, '__hash__': None, '__init__': <function Point2d.__init__>, '__match_args__': ('x', 'y')})

Point2d.__init__(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>)

additional_properties (kittycad.models.point2d.Point2d attribute)

__init__([x, y])

Method generated by attrs for class Point2d.

rtype

TypeVar(NX, bound= Point2d)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.point2d.Point2d.__init__>`\ \(\[x\, y\]\)

:py:obj:`from_dict <kittycad.models.point2d.Point2d.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.point2d.Point2d.to_dict>`\ \(\)

:py:obj:`Point3d <kittycad.models.point3d.Point3d>`\ \(\[x\, y\, z\]\)

Point3d(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>, z=<kittycad.types.Unset object>)

(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>, z=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'x': typing.Union[kittycad.types.Unset, float], 'y': typing.Union[kittycad.types.Unset, float], 'z': typing.Union[kittycad.types.Unset, float]}

(Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='z', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='z'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.point3d', '__annotations__': {'x': typing.Union[kittycad.types.Unset, float], 'y': typing.Union[kittycad.types.Unset, float], 'z': typing.Union[kittycad.types.Unset, float], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A point in 3D space', 'to_dict': <function Point3d.to_dict>, 'from_dict': <classmethod(<function Point3d.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Point3d.__getitem__>, '__setitem__': <function Point3d.__setitem__>, '__delitem__': <function Point3d.__delitem__>, '__contains__': <function Point3d.__contains__>, '__dict__': <attribute '__dict__' of 'Point3d' objects>, '__weakref__': <attribute '__weakref__' of 'Point3d' objects>, '__attrs_attrs__': (Attribute(name='x', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'), Attribute(name='z', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='z'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Point3d.__repr__>, '__eq__': <function Point3d.__eq__>, '__ne__': <function Point3d.__ne__>, '__lt__': <function Point3d.__lt__>, '__le__': <function Point3d.__le__>, '__gt__': <function Point3d.__gt__>, '__ge__': <function Point3d.__ge__>, '__hash__': None, '__init__': <function Point3d.__init__>, '__match_args__': ('x', 'y', 'z')})

Point3d.__init__(x=<kittycad.types.Unset object>, y=<kittycad.types.Unset object>, z=<kittycad.types.Unset object>)

additional_properties (kittycad.models.point3d.Point3d attribute)

__init__([x, y, z])

Method generated by attrs for class Point3d.

rtype

TypeVar(SC, bound= Point3d)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.point3d.Point3d.__init__>`\ \(\[x\, y\, z\]\)

:py:obj:`from_dict <kittycad.models.point3d.Point3d.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.point3d.Point3d.to_dict>`\ \(\)

__annotations__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

__attrs_attrs__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

__contains__() (kittycad.models.point_e_metadata.PointEMetadata method)

__delitem__() (kittycad.models.point_e_metadata.PointEMetadata method)

__dict__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

mappingproxy({'__module__': 'kittycad.models.point_e_metadata', '__annotations__': {'ok': typing.Union[kittycad.types.Unset, bool], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Metadata about our point-e instance.\n\n    This is mostly used for internal purposes and debugging.', 'to_dict': <function PointEMetadata.to_dict>, 'from_dict': <classmethod(<function PointEMetadata.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function PointEMetadata.__getitem__>, '__setitem__': <function PointEMetadata.__setitem__>, '__delitem__': <function PointEMetadata.__delitem__>, '__contains__': <function PointEMetadata.__contains__>, '__dict__': <attribute '__dict__' of 'PointEMetadata' objects>, '__weakref__': <attribute '__weakref__' of 'PointEMetadata' objects>, '__attrs_attrs__': (Attribute(name='ok', default=False, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, bool], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='ok'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function PointEMetadata.__repr__>, '__eq__': <function PointEMetadata.__eq__>, '__ne__': <function PointEMetadata.__ne__>, '__lt__': <function PointEMetadata.__lt__>, '__le__': <function PointEMetadata.__le__>, '__gt__': <function PointEMetadata.__gt__>, '__ge__': <function PointEMetadata.__ge__>, '__hash__': None, '__init__': <function PointEMetadata.__init__>, '__match_args__': ('ok',)})

__eq__() (kittycad.models.point_e_metadata.PointEMetadata method)

__ge__() (kittycad.models.point_e_metadata.PointEMetadata method)

__getitem__() (kittycad.models.point_e_metadata.PointEMetadata method)

__gt__() (kittycad.models.point_e_metadata.PointEMetadata method)

__hash__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

__init__() (kittycad.models.point_e_metadata.PointEMetadata method)

__le__() (kittycad.models.point_e_metadata.PointEMetadata method)

__lt__() (kittycad.models.point_e_metadata.PointEMetadata method)

__match_args__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

__module__ (kittycad.models.point_e_metadata.PointEMetadata attribute)

__ne__() (kittycad.models.point_e_metadata.PointEMetadata method)

__repr__() (kittycad.models.point_e_metadata.PointEMetadata method)

__setitem__() (kittycad.models.point_e_metadata.PointEMetadata method)

additional_keys (kittycad.models.point_e_metadata.PointEMetadata property)

from_dict() (kittycad.models.point_e_metadata.PointEMetadata class method)

to_dict() (kittycad.models.point_e_metadata.PointEMetadata method)

Method generated by attrs for class PointEMetadata.

rtype

TypeVar(TX, bound= PointEMetadata)

to_dict()

rtype

{'additional_properties': typing.Dict[str, typing.Any], 'message': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='message'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.pong', '__annotations__': {'message': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The response from the `/ping` endpoint.', 'to_dict': <function Pong.to_dict>, 'from_dict': <classmethod(<function Pong.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Pong.__getitem__>, '__setitem__': <function Pong.__setitem__>, '__delitem__': <function Pong.__delitem__>, '__contains__': <function Pong.__contains__>, '__dict__': <attribute '__dict__' of 'Pong' objects>, '__weakref__': <attribute '__weakref__' of 'Pong' objects>, '__attrs_attrs__': (Attribute(name='message', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='message'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Pong.__repr__>, '__eq__': <function Pong.__eq__>, '__ne__': <function Pong.__ne__>, '__lt__': <function Pong.__lt__>, '__le__': <function Pong.__le__>, '__gt__': <function Pong.__gt__>, '__ge__': <function Pong.__ge__>, '__hash__': None, '__init__': <function Pong.__init__>, '__match_args__': ('message',)})

__init__([message])

Method generated by attrs for class Pong.

rtype

TypeVar(JA, bound= Pong)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.pong.Pong.__init__>`\ \(\[message\]\)

:py:obj:`from_dict <kittycad.models.pong.Pong.from_dict>`\ \(src\_dict\)

RegistryServiceConfig([...])

RegistryServiceConfig stores daemon registry services configuration.

RegistryServiceConfig (class in kittycad.models.registry_service_config)

RegistryServiceConfig(allow_nondistributable_artifacts_cid_rs=<kittycad.types.Unset object>, allow_nondistributable_artifacts_hostnames=<kittycad.types.Unset object>, index_configs=<kittycad.types.Unset object>, insecure_registry_cid_rs=<kittycad.types.Unset object>, mirrors=<kittycad.types.Unset object>)

(allow_nondistributable_artifacts_cid_rs=<kittycad.types.Unset object>, allow_nondistributable_artifacts_hostnames=<kittycad.types.Unset object>, index_configs=<kittycad.types.Unset object>, insecure_registry_cid_rs=<kittycad.types.Unset object>, mirrors=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'allow_nondistributable_artifacts_cid_rs': typing.Union[kittycad.types.Unset, typing.List[str]], 'allow_nondistributable_artifacts_hostnames': typing.Union[kittycad.types.Unset, typing.List[str]], 'index_configs': typing.Union[kittycad.types.Unset, typing.Any], 'insecure_registry_cid_rs': typing.Union[kittycad.types.Unset, typing.List[str]], 'mirrors': typing.Union[kittycad.types.Unset, typing.List[str]]}

(Attribute(name='allow_nondistributable_artifacts_cid_rs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='allow_nondistributable_artifacts_cid_rs'), Attribute(name='allow_nondistributable_artifacts_hostnames', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='allow_nondistributable_artifacts_hostnames'), Attribute(name='index_configs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='index_configs'), Attribute(name='insecure_registry_cid_rs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='insecure_registry_cid_rs'), Attribute(name='mirrors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mirrors'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.registry_service_config', '__annotations__': {'allow_nondistributable_artifacts_cid_rs': typing.Union[kittycad.types.Unset, typing.List[str]], 'allow_nondistributable_artifacts_hostnames': typing.Union[kittycad.types.Unset, typing.List[str]], 'index_configs': typing.Union[kittycad.types.Unset, typing.Any], 'insecure_registry_cid_rs': typing.Union[kittycad.types.Unset, typing.List[str]], 'mirrors': typing.Union[kittycad.types.Unset, typing.List[str]], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'RegistryServiceConfig stores daemon registry services configuration.', 'to_dict': <function RegistryServiceConfig.to_dict>, 'from_dict': <classmethod(<function RegistryServiceConfig.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function RegistryServiceConfig.__getitem__>, '__setitem__': <function RegistryServiceConfig.__setitem__>, '__delitem__': <function RegistryServiceConfig.__delitem__>, '__contains__': <function RegistryServiceConfig.__contains__>, '__dict__': <attribute '__dict__' of 'RegistryServiceConfig' objects>, '__weakref__': <attribute '__weakref__' of 'RegistryServiceConfig' objects>, '__attrs_attrs__': (Attribute(name='allow_nondistributable_artifacts_cid_rs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='allow_nondistributable_artifacts_cid_rs'), Attribute(name='allow_nondistributable_artifacts_hostnames', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='allow_nondistributable_artifacts_hostnames'), Attribute(name='index_configs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='index_configs'), Attribute(name='insecure_registry_cid_rs', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='insecure_registry_cid_rs'), Attribute(name='mirrors', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mirrors'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function RegistryServiceConfig.__repr__>, '__eq__': <function RegistryServiceConfig.__eq__>, '__ne__': <function RegistryServiceConfig.__ne__>, '__lt__': <function RegistryServiceConfig.__lt__>, '__le__': <function RegistryServiceConfig.__le__>, '__gt__': <function RegistryServiceConfig.__gt__>, '__ge__': <function RegistryServiceConfig.__ge__>, '__hash__': None, '__init__': <function RegistryServiceConfig.__init__>, '__match_args__': ('allow_nondistributable_artifacts_cid_rs', 'allow_nondistributable_artifacts_hostnames', 'index_configs', 'insecure_registry_cid_rs', 'mirrors')})

__eq__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

__ge__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

__gt__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

RegistryServiceConfig.__init__(allow_nondistributable_artifacts_cid_rs=<kittycad.types.Unset object>, allow_nondistributable_artifacts_hostnames=<kittycad.types.Unset object>, index_configs=<kittycad.types.Unset object>, insecure_registry_cid_rs=<kittycad.types.Unset object>, mirrors=<kittycad.types.Unset object>)

__le__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

__lt__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

('allow_nondistributable_artifacts_cid_rs', 'allow_nondistributable_artifacts_hostnames', 'index_configs', 'insecure_registry_cid_rs', 'mirrors')

__ne__() (kittycad.models.registry_service_config.RegistryServiceConfig method)

from_dict() (kittycad.models.registry_service_config.RegistryServiceConfig class method)

to_dict() (kittycad.models.registry_service_config.RegistryServiceConfig method)

Method generated by attrs for class RegistryServiceConfig.

rtype

TypeVar(SK, bound= RegistryServiceConfig)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``SK``, bound= RegistryServiceConfig)

allow_nondistributable_artifacts_cid_rs

allow_nondistributable_artifacts_hostnames

index_configs

insecure_registry_cid_rs

mirrors

Runtime([path, runtime_args])

Runtime describes an [OCI compliant](https://github.com/opencontainers/runtime-spec) runtime.

:py:obj:`Runtime <kittycad.models.runtime.Runtime>`\ \(\[path\, runtime\_args\]\)

Runtime(path=<kittycad.types.Unset object>, runtime_args=<kittycad.types.Unset object>)

(path=<kittycad.types.Unset object>, runtime_args=<kittycad.types.Unset object>)

Runtime describes an [OCI compliant](https://github.com/opencontainers/runtime-spec) runtime.  The runtime is invoked by the daemon via the `containerd` daemon. OCI runtimes act as an interface to the Linux kernel namespaces, cgroups, and SELinux.

 daemon. OCI runtimes act as an interface to the Linux kernel namespaces, cgroups, and SELinux.

{'additional_properties': typing.Dict[str, typing.Any], 'path': typing.Union[kittycad.types.Unset, str], 'runtime_args': typing.Union[kittycad.types.Unset, typing.List[str]]}

(Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='runtime_args', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runtime_args'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.runtime', '__annotations__': {'path': typing.Union[kittycad.types.Unset, str], 'runtime_args': typing.Union[kittycad.types.Unset, typing.List[str]], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Runtime describes an [OCI compliant](https://github.com/opencontainers/runtime-spec) runtime.  The runtime is invoked by the daemon via the `containerd` daemon. OCI runtimes act as an interface to the Linux kernel namespaces, cgroups, and SELinux.', 'to_dict': <function Runtime.to_dict>, 'from_dict': <classmethod(<function Runtime.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Runtime.__getitem__>, '__setitem__': <function Runtime.__setitem__>, '__delitem__': <function Runtime.__delitem__>, '__contains__': <function Runtime.__contains__>, '__dict__': <attribute '__dict__' of 'Runtime' objects>, '__weakref__': <attribute '__weakref__' of 'Runtime' objects>, '__attrs_attrs__': (Attribute(name='path', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='path'), Attribute(name='runtime_args', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[str]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='runtime_args'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Runtime.__repr__>, '__eq__': <function Runtime.__eq__>, '__ne__': <function Runtime.__ne__>, '__lt__': <function Runtime.__lt__>, '__le__': <function Runtime.__le__>, '__gt__': <function Runtime.__gt__>, '__ge__': <function Runtime.__ge__>, '__hash__': None, '__init__': <function Runtime.__init__>, '__match_args__': ('path', 'runtime_args')})

Runtime.__init__(path=<kittycad.types.Unset object>, runtime_args=<kittycad.types.Unset object>)

additional_properties (kittycad.models.runtime.Runtime attribute)

__init__([path, runtime_args])

Method generated by attrs for class Runtime.

rtype

TypeVar(UK, bound= Runtime)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.runtime.Runtime.__init__>`\ \(\[path\, runtime\_args\]\)

:py:obj:`from_dict <kittycad.models.runtime.Runtime.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.runtime.Runtime.to_dict>`\ \(\)

path

runtime_args

SceneSelectionType(value[, names, module, ...])

The type of scene selection change

:py:obj:`SceneSelectionType <kittycad.models.scene_selection_type.SceneSelectionType>`\ \(value\[\, names\, module\, ...\]\)

SceneSelectionType (class in kittycad.models.scene_selection_type)

SceneSelectionType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

ADD (kittycad.models.scene_selection_type.SceneSelectionType attribute)

docstring of kittycad.models.scene_selection_type.SceneSelectionType.ADD

REMOVE (kittycad.models.scene_selection_type.SceneSelectionType attribute)

REPLACE (kittycad.models.scene_selection_type.SceneSelectionType attribute)

docstring of kittycad.models.scene_selection_type.SceneSelectionType.REPLACE

__add__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__contains__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__dict__ (kittycad.models.scene_selection_type.SceneSelectionType attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.scene_selection_type', '__doc__': 'The type of scene selection change', '__str__': <function SceneSelectionType.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['REPLACE', 'ADD', 'REMOVE'], '_member_map_': {'REPLACE': <SceneSelectionType.REPLACE: 'replace'>, 'ADD': <SceneSelectionType.ADD: 'add'>, 'REMOVE': <SceneSelectionType.REMOVE: 'remove'>}, '_value2member_map_': {'replace': <SceneSelectionType.REPLACE: 'replace'>, 'add': <SceneSelectionType.ADD: 'add'>, 'remove': <SceneSelectionType.REMOVE: 'remove'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'SceneSelectionType' objects>, '__weakref__': <attribute '__weakref__' of 'SceneSelectionType' objects>, 'REPLACE': <SceneSelectionType.REPLACE: 'replace'>, 'ADD': <SceneSelectionType.ADD: 'add'>, 'REMOVE': <SceneSelectionType.REMOVE: 'remove'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__eq__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__format__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__ge__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__getitem__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__gt__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__hash__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__init__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__iter__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__le__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__len__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__lt__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__mod__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__module__ (kittycad.models.scene_selection_type.SceneSelectionType attribute)

__mul__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__ne__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__new__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__reduce_ex__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__repr__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__rmod__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__rmul__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__sizeof__() (kittycad.models.scene_selection_type.SceneSelectionType method)

__str__() (kittycad.models.scene_selection_type.SceneSelectionType method)

SceneSelectionType._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.scene_selection_type.SceneSelectionType attribute)

{'ADD': SceneSelectionType.ADD, 'REMOVE': SceneSelectionType.REMOVE, 'REPLACE': SceneSelectionType.REPLACE}

_new_member_() (kittycad.models.scene_selection_type.SceneSelectionType method)

_use_args_ (kittycad.models.scene_selection_type.SceneSelectionType attribute)

{'add': SceneSelectionType.ADD, 'remove': SceneSelectionType.REMOVE, 'replace': SceneSelectionType.REPLACE}

_value_repr_() (kittycad.models.scene_selection_type.SceneSelectionType method)

capitalize() (kittycad.models.scene_selection_type.SceneSelectionType method)

casefold() (kittycad.models.scene_selection_type.SceneSelectionType method)

center() (kittycad.models.scene_selection_type.SceneSelectionType method)

count() (kittycad.models.scene_selection_type.SceneSelectionType method)

encode() (kittycad.models.scene_selection_type.SceneSelectionType method)

endswith() (kittycad.models.scene_selection_type.SceneSelectionType method)

expandtabs() (kittycad.models.scene_selection_type.SceneSelectionType method)

find() (kittycad.models.scene_selection_type.SceneSelectionType method)

format() (kittycad.models.scene_selection_type.SceneSelectionType method)

format_map() (kittycad.models.scene_selection_type.SceneSelectionType method)

index() (kittycad.models.scene_selection_type.SceneSelectionType method)

isalnum() (kittycad.models.scene_selection_type.SceneSelectionType method)

isalpha() (kittycad.models.scene_selection_type.SceneSelectionType method)

isascii() (kittycad.models.scene_selection_type.SceneSelectionType method)

isdecimal() (kittycad.models.scene_selection_type.SceneSelectionType method)

isdigit() (kittycad.models.scene_selection_type.SceneSelectionType method)

isidentifier() (kittycad.models.scene_selection_type.SceneSelectionType method)

islower() (kittycad.models.scene_selection_type.SceneSelectionType method)

isnumeric() (kittycad.models.scene_selection_type.SceneSelectionType method)

isprintable() (kittycad.models.scene_selection_type.SceneSelectionType method)

isspace() (kittycad.models.scene_selection_type.SceneSelectionType method)

istitle() (kittycad.models.scene_selection_type.SceneSelectionType method)

isupper() (kittycad.models.scene_selection_type.SceneSelectionType method)

join() (kittycad.models.scene_selection_type.SceneSelectionType method)

ljust() (kittycad.models.scene_selection_type.SceneSelectionType method)

lower() (kittycad.models.scene_selection_type.SceneSelectionType method)

lstrip() (kittycad.models.scene_selection_type.SceneSelectionType method)

maketrans() (kittycad.models.scene_selection_type.SceneSelectionType static method)

partition() (kittycad.models.scene_selection_type.SceneSelectionType method)

removeprefix() (kittycad.models.scene_selection_type.SceneSelectionType method)

removesuffix() (kittycad.models.scene_selection_type.SceneSelectionType method)

replace() (kittycad.models.scene_selection_type.SceneSelectionType method)

rfind() (kittycad.models.scene_selection_type.SceneSelectionType method)

rindex() (kittycad.models.scene_selection_type.SceneSelectionType method)

rjust() (kittycad.models.scene_selection_type.SceneSelectionType method)

rpartition() (kittycad.models.scene_selection_type.SceneSelectionType method)

rsplit() (kittycad.models.scene_selection_type.SceneSelectionType method)

rstrip() (kittycad.models.scene_selection_type.SceneSelectionType method)

split() (kittycad.models.scene_selection_type.SceneSelectionType method)

splitlines() (kittycad.models.scene_selection_type.SceneSelectionType method)

startswith() (kittycad.models.scene_selection_type.SceneSelectionType method)

strip() (kittycad.models.scene_selection_type.SceneSelectionType method)

swapcase() (kittycad.models.scene_selection_type.SceneSelectionType method)

title() (kittycad.models.scene_selection_type.SceneSelectionType method)

translate() (kittycad.models.scene_selection_type.SceneSelectionType method)

upper() (kittycad.models.scene_selection_type.SceneSelectionType method)

zfill() (kittycad.models.scene_selection_type.SceneSelectionType method)

:py:obj:`__init__ <kittycad.models.scene_selection_type.SceneSelectionType.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.scene_selection_type.SceneSelectionType.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.scene_selection_type.SceneSelectionType.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.scene_selection_type.SceneSelectionType.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.scene_selection_type.SceneSelectionType.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.scene_selection_type.SceneSelectionType.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.scene_selection_type.SceneSelectionType.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.scene_selection_type.SceneSelectionType.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.scene_selection_type.SceneSelectionType.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.scene_selection_type.SceneSelectionType.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.scene_selection_type.SceneSelectionType.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.scene_selection_type.SceneSelectionType.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.scene_selection_type.SceneSelectionType.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.scene_selection_type.SceneSelectionType.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.scene_selection_type.SceneSelectionType.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.scene_selection_type.SceneSelectionType.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.scene_selection_type.SceneSelectionType.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.scene_selection_type.SceneSelectionType.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.scene_selection_type.SceneSelectionType.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.scene_selection_type.SceneSelectionType.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.scene_selection_type.SceneSelectionType.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.scene_selection_type.SceneSelectionType.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.scene_selection_type.SceneSelectionType.zfill>`\ \(width\, \/\)

REPLACE

# Adds to the selection

ADD

# Removes from the selection

REMOVE

Session([created_at, expires, id, ...])

An authentication session.

:py:obj:`Session <kittycad.models.session.Session>`\ \(\[created\_at\, expires\, id\, ...\]\)

Session(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, session_token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, session_token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'expires': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'session_token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='expires', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expires'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='session_token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='session_token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.session', '__annotations__': {'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'expires': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'session_token': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'An authentication session.\n\n    For our UIs, these are automatically created by Next.js.', 'to_dict': <function Session.to_dict>, 'from_dict': <classmethod(<function Session.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function Session.__getitem__>, '__setitem__': <function Session.__setitem__>, '__delitem__': <function Session.__delitem__>, '__contains__': <function Session.__contains__>, '__dict__': <attribute '__dict__' of 'Session' objects>, '__weakref__': <attribute '__weakref__' of 'Session' objects>, '__attrs_attrs__': (Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='expires', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expires'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='session_token', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='session_token'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function Session.__repr__>, '__eq__': <function Session.__eq__>, '__ne__': <function Session.__ne__>, '__lt__': <function Session.__lt__>, '__le__': <function Session.__le__>, '__gt__': <function Session.__gt__>, '__ge__': <function Session.__ge__>, '__hash__': None, '__init__': <function Session.__init__>, '__match_args__': ('created_at', 'expires', 'id', 'session_token', 'updated_at', 'user_id')})

Session.__init__(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, session_token=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

('created_at', 'expires', 'id', 'session_token', 'updated_at', 'user_id')

additional_properties (kittycad.models.session.Session attribute)

__init__([created_at, expires, id, ...])

Method generated by attrs for class Session.

rtype

TypeVar(CX, bound= Session)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.session.Session.__init__>`\ \(\[created\_at\, expires\, id\, ...\]\)

:py:obj:`from_dict <kittycad.models.session.Session.from_dict>`\ \(src\_dict\)

:py:obj:`to_dict <kittycad.models.session.Session.to_dict>`\ \(\)

expires

id

session_token

user_id

Storage(value[, names, module, qualname, ...])

Describes the storage format of a glTF 2.0 scene.

:py:obj:`Storage <kittycad.models.storage.Storage>`\ \(value\[\, names\, module\, qualname\, ...\]\)

Storage(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

This is a JSON file with .gltf extension paired with a separate binary blob file with .bin extension.

Single JSON file with .gltf extension binary data encoded as base64 data URIs.

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.storage', '__doc__': 'Describes the storage format of a glTF 2.0 scene.', '__str__': <function Storage.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['BINARY', 'STANDARD', 'EMBEDDED'], '_member_map_': {'BINARY': <Storage.BINARY: 'binary'>, 'STANDARD': <Storage.STANDARD: 'standard'>, 'EMBEDDED': <Storage.EMBEDDED: 'embedded'>}, '_value2member_map_': {'binary': <Storage.BINARY: 'binary'>, 'standard': <Storage.STANDARD: 'standard'>, 'embedded': <Storage.EMBEDDED: 'embedded'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'Storage' objects>, '__weakref__': <attribute '__weakref__' of 'Storage' objects>, 'BINARY': <Storage.BINARY: 'binary'>, 'STANDARD': <Storage.STANDARD: 'standard'>, 'EMBEDDED': <Storage.EMBEDDED: 'embedded'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

_generate_next_value_() (kittycad.models.storage.Storage method)

{'BINARY': Storage.BINARY, 'EMBEDDED': Storage.EMBEDDED, 'STANDARD': Storage.STANDARD}

{'binary': Storage.BINARY, 'embedded': Storage.EMBEDDED, 'standard': Storage.STANDARD}

:py:obj:`__init__ <kittycad.models.storage.Storage.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.storage.Storage.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.storage.Storage.casefold>`\ \(\)

:py:obj:`center <kittycad.models.storage.Storage.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.storage.Storage.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.storage.Storage.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.storage.Storage.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.storage.Storage.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.storage.Storage.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`format_map <kittycad.models.storage.Storage.format_map>`\ \(mapping\)

:py:obj:`index <kittycad.models.storage.Storage.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.storage.Storage.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.storage.Storage.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.storage.Storage.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.storage.Storage.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.storage.Storage.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.storage.Storage.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.storage.Storage.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.storage.Storage.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.storage.Storage.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.storage.Storage.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.storage.Storage.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.storage.Storage.isupper>`\ \(\)

:py:obj:`join <kittycad.models.storage.Storage.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.storage.Storage.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lstrip <kittycad.models.storage.Storage.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.storage.Storage.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.storage.Storage.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.storage.Storage.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.storage.Storage.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.storage.Storage.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.storage.Storage.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.storage.Storage.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.storage.Storage.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.storage.Storage.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.storage.Storage.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.storage.Storage.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.storage.Storage.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.storage.Storage.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.storage.Storage.swapcase>`\ \(\)

:py:obj:`translate <kittycad.models.storage.Storage.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.storage.Storage.zfill>`\ \(width\, \/\)

BINARY

# Standard glTF 2.0.

STANDARD

# Embedded glTF 2.0.

EMBEDDED

:py:obj:`System <kittycad.models.system.System>`\ \(\[forward\, up\]\)

System(forward=<kittycad.types.Unset object>, up=<kittycad.types.Unset object>)

(forward=<kittycad.types.Unset object>, up=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'forward': typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], 'up': typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair]}

(Attribute(name='forward', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='forward'), Attribute(name='up', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='up'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.system', '__annotations__': {'forward': typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], 'up': typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Co-ordinate system definition.\n\n    The `up` axis must be orthogonal to the `forward` axis.\n\n    See [cglearn.eu] for background reading.\n\n    [cglearn.eu](https://cglearn.eu/pub/computer-graphics/introduction-to-geometry#material-coordinate-systems-1)\n    ', 'to_dict': <function System.to_dict>, 'from_dict': <classmethod(<function System.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function System.__getitem__>, '__setitem__': <function System.__setitem__>, '__delitem__': <function System.__delitem__>, '__contains__': <function System.__contains__>, '__dict__': <attribute '__dict__' of 'System' objects>, '__weakref__': <attribute '__weakref__' of 'System' objects>, '__attrs_attrs__': (Attribute(name='forward', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='forward'), Attribute(name='up', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.axis_direction_pair.AxisDirectionPair], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='up'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function System.__repr__>, '__eq__': <function System.__eq__>, '__ne__': <function System.__ne__>, '__lt__': <function System.__lt__>, '__le__': <function System.__le__>, '__gt__': <function System.__gt__>, '__ge__': <function System.__ge__>, '__hash__': None, '__init__': <function System.__init__>, '__match_args__': ('forward', 'up')})

System.__init__(forward=<kittycad.types.Unset object>, up=<kittycad.types.Unset object>)

__init__([forward, up])

Method generated by attrs for class System.

rtype

TypeVar(MT, bound= System)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.system.System.__init__>`\ \(\[forward\, up\]\)

:py:obj:`from_dict <kittycad.models.system.System.from_dict>`\ \(src\_dict\)

:py:obj:`SystemInfoCgroupDriverEnum <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum>`\ \(value\[\, names\, ...\]\)

SystemInfoCgroupDriverEnum (class in kittycad.models.system_info_cgroup_driver_enum)

SystemInfoCgroupDriverEnum(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.system_info_cgroup_driver_enum', '__str__': <function SystemInfoCgroupDriverEnum.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['EMPTY', 'CGROUPFS', 'SYSTEMD', 'NONE'], '_member_map_': {'EMPTY': <SystemInfoCgroupDriverEnum.EMPTY: ''>, 'CGROUPFS': <SystemInfoCgroupDriverEnum.CGROUPFS: 'cgroupfs'>, 'SYSTEMD': <SystemInfoCgroupDriverEnum.SYSTEMD: 'systemd'>, 'NONE': <SystemInfoCgroupDriverEnum.NONE: 'none'>}, '_value2member_map_': {'': <SystemInfoCgroupDriverEnum.EMPTY: ''>, 'cgroupfs': <SystemInfoCgroupDriverEnum.CGROUPFS: 'cgroupfs'>, 'systemd': <SystemInfoCgroupDriverEnum.SYSTEMD: 'systemd'>, 'none': <SystemInfoCgroupDriverEnum.NONE: 'none'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'SystemInfoCgroupDriverEnum' objects>, '__weakref__': <attribute '__weakref__' of 'SystemInfoCgroupDriverEnum' objects>, '__doc__': None, 'EMPTY': <SystemInfoCgroupDriverEnum.EMPTY: ''>, 'CGROUPFS': <SystemInfoCgroupDriverEnum.CGROUPFS: 'cgroupfs'>, 'SYSTEMD': <SystemInfoCgroupDriverEnum.SYSTEMD: 'systemd'>, 'NONE': <SystemInfoCgroupDriverEnum.NONE: 'none'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

SystemInfoCgroupDriverEnum._generate_next_value_(start, count, last_values)

{'CGROUPFS': SystemInfoCgroupDriverEnum.CGROUPFS, 'EMPTY': SystemInfoCgroupDriverEnum.EMPTY, 'NONE': SystemInfoCgroupDriverEnum.NONE, 'SYSTEMD': SystemInfoCgroupDriverEnum.SYSTEMD}

{'': SystemInfoCgroupDriverEnum.EMPTY, 'cgroupfs': SystemInfoCgroupDriverEnum.CGROUPFS, 'none': SystemInfoCgroupDriverEnum.NONE, 'systemd': SystemInfoCgroupDriverEnum.SYSTEMD}

SystemInfoCgroupDriverEnum.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum static method)

SystemInfoCgroupDriverEnum.startswith(prefix[, start[, end]]) -> bool

:py:obj:`count <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`endswith <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`index <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.join>`\ \(iterable\, \/\)

:py:obj:`partition <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.partition>`\ \(sep\, \/\)

:py:obj:`replace <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`startswith <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`zfill <kittycad.models.system_info_cgroup_driver_enum.SystemInfoCgroupDriverEnum.zfill>`\ \(width\, \/\)

:py:obj:`SystemInfoCgroupVersionEnum <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum>`\ \(value\[\, names\, ...\]\)

SystemInfoCgroupVersionEnum (class in kittycad.models.system_info_cgroup_version_enum)

SystemInfoCgroupVersionEnum(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.system_info_cgroup_version_enum', '__str__': <function SystemInfoCgroupVersionEnum.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['EMPTY', 'ONE', 'TWO'], '_member_map_': {'EMPTY': <SystemInfoCgroupVersionEnum.EMPTY: ''>, 'ONE': <SystemInfoCgroupVersionEnum.ONE: '1'>, 'TWO': <SystemInfoCgroupVersionEnum.TWO: '2'>}, '_value2member_map_': {'': <SystemInfoCgroupVersionEnum.EMPTY: ''>, '1': <SystemInfoCgroupVersionEnum.ONE: '1'>, '2': <SystemInfoCgroupVersionEnum.TWO: '2'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'SystemInfoCgroupVersionEnum' objects>, '__weakref__': <attribute '__weakref__' of 'SystemInfoCgroupVersionEnum' objects>, '__doc__': None, 'EMPTY': <SystemInfoCgroupVersionEnum.EMPTY: ''>, 'ONE': <SystemInfoCgroupVersionEnum.ONE: '1'>, 'TWO': <SystemInfoCgroupVersionEnum.TWO: '2'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

SystemInfoCgroupVersionEnum._generate_next_value_(start, count, last_values)

{'EMPTY': SystemInfoCgroupVersionEnum.EMPTY, 'ONE': SystemInfoCgroupVersionEnum.ONE, 'TWO': SystemInfoCgroupVersionEnum.TWO}

{'': SystemInfoCgroupVersionEnum.EMPTY, '1': SystemInfoCgroupVersionEnum.ONE, '2': SystemInfoCgroupVersionEnum.TWO}

SystemInfoCgroupVersionEnum.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum static method)

SystemInfoCgroupVersionEnum.startswith(prefix[, start[, end]]) -> bool

:py:obj:`count <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`endswith <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`index <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.join>`\ \(iterable\, \/\)

:py:obj:`replace <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`startswith <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`zfill <kittycad.models.system_info_cgroup_version_enum.SystemInfoCgroupVersionEnum.zfill>`\ \(width\, \/\)

SystemInfoDefaultAddressPools([base, size])

SystemInfoDefaultAddressPools (class in kittycad.models.system_info_default_address_pools)

SystemInfoDefaultAddressPools(base=<kittycad.types.Unset object>, size=<kittycad.types.Unset object>)

SystemInfoDefaultAddressPools.__init__(base=<kittycad.types.Unset object>, size=<kittycad.types.Unset object>)

from_dict() (kittycad.models.system_info_default_address_pools.SystemInfoDefaultAddressPools class method)

__init__([base, size])

rtype

TypeVar(LJ, bound= SystemInfoDefaultAddressPools)

to_dict()

rtype

:py:class:`~typing.TypeVar`\(``LJ``, bound= SystemInfoDefaultAddressPools)

:py:obj:`SystemInfoIsolationEnum <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum>`\ \(value\[\, names\, ...\]\)

SystemInfoIsolationEnum (class in kittycad.models.system_info_isolation_enum)

SystemInfoIsolationEnum(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.system_info_isolation_enum', '__str__': <function SystemInfoIsolationEnum.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['EMPTY', 'DEFAULT', 'HYPERV', 'PROCESS'], '_member_map_': {'EMPTY': <SystemInfoIsolationEnum.EMPTY: ''>, 'DEFAULT': <SystemInfoIsolationEnum.DEFAULT: 'default'>, 'HYPERV': <SystemInfoIsolationEnum.HYPERV: 'hyperv'>, 'PROCESS': <SystemInfoIsolationEnum.PROCESS: 'process'>}, '_value2member_map_': {'': <SystemInfoIsolationEnum.EMPTY: ''>, 'default': <SystemInfoIsolationEnum.DEFAULT: 'default'>, 'hyperv': <SystemInfoIsolationEnum.HYPERV: 'hyperv'>, 'process': <SystemInfoIsolationEnum.PROCESS: 'process'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'SystemInfoIsolationEnum' objects>, '__weakref__': <attribute '__weakref__' of 'SystemInfoIsolationEnum' objects>, '__doc__': None, 'EMPTY': <SystemInfoIsolationEnum.EMPTY: ''>, 'DEFAULT': <SystemInfoIsolationEnum.DEFAULT: 'default'>, 'HYPERV': <SystemInfoIsolationEnum.HYPERV: 'hyperv'>, 'PROCESS': <SystemInfoIsolationEnum.PROCESS: 'process'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

SystemInfoIsolationEnum._generate_next_value_(start, count, last_values)

{'DEFAULT': SystemInfoIsolationEnum.DEFAULT, 'EMPTY': SystemInfoIsolationEnum.EMPTY, 'HYPERV': SystemInfoIsolationEnum.HYPERV, 'PROCESS': SystemInfoIsolationEnum.PROCESS}

{'': SystemInfoIsolationEnum.EMPTY, 'default': SystemInfoIsolationEnum.DEFAULT, 'hyperv': SystemInfoIsolationEnum.HYPERV, 'process': SystemInfoIsolationEnum.PROCESS}

SystemInfoIsolationEnum.endswith(suffix[, start[, end]]) -> bool

maketrans() (kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum static method)

SystemInfoIsolationEnum.startswith(prefix[, start[, end]]) -> bool

:py:obj:`__init__ <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`partition <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.partition>`\ \(sep\, \/\)

:py:obj:`replace <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`translate <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.system_info_isolation_enum.SystemInfoIsolationEnum.zfill>`\ \(width\, \/\)

UnitAngle(value[, names, module, qualname, ...])

The valid types of angle formats.

:py:obj:`UnitAngle <kittycad.models.unit_angle.UnitAngle>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitAngle(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.unit_angle.UnitAngle attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_angle', '__doc__': 'The valid types of angle formats.', '__str__': <function UnitAngle.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['DEGREES', 'RADIANS'], '_member_map_': {'DEGREES': <UnitAngle.DEGREES: 'degrees'>, 'RADIANS': <UnitAngle.RADIANS: 'radians'>}, '_value2member_map_': {'degrees': <UnitAngle.DEGREES: 'degrees'>, 'radians': <UnitAngle.RADIANS: 'radians'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitAngle' objects>, '__weakref__': <attribute '__weakref__' of 'UnitAngle' objects>, 'DEGREES': <UnitAngle.DEGREES: 'degrees'>, 'RADIANS': <UnitAngle.RADIANS: 'radians'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_angle.UnitAngle method)

_generate_next_value_() (kittycad.models.unit_angle.UnitAngle method)

_unhashable_values_ (kittycad.models.unit_angle.UnitAngle attribute)

_value2member_map_ (kittycad.models.unit_angle.UnitAngle attribute)

maketrans() (kittycad.models.unit_angle.UnitAngle static method)

:py:obj:`__init__ <kittycad.models.unit_angle.UnitAngle.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_angle.UnitAngle.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_angle.UnitAngle.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_angle.UnitAngle.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_angle.UnitAngle.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_angle.UnitAngle.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_angle.UnitAngle.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_angle.UnitAngle.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_angle.UnitAngle.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_angle.UnitAngle.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_angle.UnitAngle.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_angle.UnitAngle.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_angle.UnitAngle.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_angle.UnitAngle.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_angle.UnitAngle.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.unit_angle.UnitAngle.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.unit_angle.UnitAngle.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_angle.UnitAngle.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_angle.UnitAngle.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_angle.UnitAngle.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_angle.UnitAngle.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_angle.UnitAngle.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_angle.UnitAngle.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_angle.UnitAngle.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_angle.UnitAngle.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_angle.UnitAngle.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_angle.UnitAngle.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_angle.UnitAngle.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_angle.UnitAngle.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_angle.UnitAngle.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_angle.UnitAngle.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_angle.UnitAngle.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_angle.UnitAngle.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_angle.UnitAngle.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_angle.UnitAngle.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_angle.UnitAngle.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_angle.UnitAngle.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_angle.UnitAngle.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_angle.UnitAngle.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_angle.UnitAngle.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_angle.UnitAngle.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_angle.UnitAngle.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_angle.UnitAngle.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_angle.UnitAngle.zfill>`\ \(width\, \/\)

UnitAngleConversion([completed_at, ...])

Result of converting between units.

:py:obj:`UnitAngleConversion <kittycad.models.unit_angle_conversion.UnitAngleConversion>`\ \(\[completed\_at\, ...\]\)

UnitAngleConversion (class in kittycad.models.unit_angle_conversion)

UnitAngleConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__delitem__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__dict__ (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_angle_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitAngleConversion.to_dict>, 'from_dict': <classmethod(<function UnitAngleConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitAngleConversion.__getitem__>, '__setitem__': <function UnitAngleConversion.__setitem__>, '__delitem__': <function UnitAngleConversion.__delitem__>, '__contains__': <function UnitAngleConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitAngleConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitAngleConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_angle.UnitAngle], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitAngleConversion.__repr__>, '__eq__': <function UnitAngleConversion.__eq__>, '__ne__': <function UnitAngleConversion.__ne__>, '__lt__': <function UnitAngleConversion.__lt__>, '__le__': <function UnitAngleConversion.__le__>, '__gt__': <function UnitAngleConversion.__gt__>, '__ge__': <function UnitAngleConversion.__ge__>, '__hash__': None, '__init__': <function UnitAngleConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__ge__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__getitem__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__gt__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__hash__ (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

__init__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

UnitAngleConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__lt__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')

__module__ (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

__ne__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__repr__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

__setitem__() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

created_at (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

error (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

from_dict() (kittycad.models.unit_angle_conversion.UnitAngleConversion class method)

id (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

input (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

input_unit (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

output (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

started_at (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

status (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

to_dict() (kittycad.models.unit_angle_conversion.UnitAngleConversion method)

updated_at (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

user_id (kittycad.models.unit_angle_conversion.UnitAngleConversion attribute)

Method generated by attrs for class UnitAngleConversion.

rtype

TypeVar(TF, bound= UnitAngleConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_angle_conversion.UnitAngleConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``TF``, bound= UnitAngleConversion)

error

id

input

input_unit

output

status

user_id

UnitArea(value[, names, module, qualname, ...])

The valid types of area units.

:py:obj:`UnitArea <kittycad.models.unit_area.UnitArea>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitArea(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_area', '__doc__': 'The valid types of area units.', '__str__': <function UnitArea.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CM2', 'DM2', 'FT2', 'IN2', 'KM2', 'M2', 'MM2', 'YD2'], '_member_map_': {'CM2': <UnitArea.CM2: 'cm2'>, 'DM2': <UnitArea.DM2: 'dm2'>, 'FT2': <UnitArea.FT2: 'ft2'>, 'IN2': <UnitArea.IN2: 'in2'>, 'KM2': <UnitArea.KM2: 'km2'>, 'M2': <UnitArea.M2: 'm2'>, 'MM2': <UnitArea.MM2: 'mm2'>, 'YD2': <UnitArea.YD2: 'yd2'>}, '_value2member_map_': {'cm2': <UnitArea.CM2: 'cm2'>, 'dm2': <UnitArea.DM2: 'dm2'>, 'ft2': <UnitArea.FT2: 'ft2'>, 'in2': <UnitArea.IN2: 'in2'>, 'km2': <UnitArea.KM2: 'km2'>, 'm2': <UnitArea.M2: 'm2'>, 'mm2': <UnitArea.MM2: 'mm2'>, 'yd2': <UnitArea.YD2: 'yd2'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitArea' objects>, '__weakref__': <attribute '__weakref__' of 'UnitArea' objects>, 'CM2': <UnitArea.CM2: 'cm2'>, 'DM2': <UnitArea.DM2: 'dm2'>, 'FT2': <UnitArea.FT2: 'ft2'>, 'IN2': <UnitArea.IN2: 'in2'>, 'KM2': <UnitArea.KM2: 'km2'>, 'M2': <UnitArea.M2: 'm2'>, 'MM2': <UnitArea.MM2: 'mm2'>, 'YD2': <UnitArea.YD2: 'yd2'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

_generate_next_value_() (kittycad.models.unit_area.UnitArea method)

{'CM2': UnitArea.CM2, 'DM2': UnitArea.DM2, 'FT2': UnitArea.FT2, 'IN2': UnitArea.IN2, 'KM2': UnitArea.KM2, 'M2': UnitArea.M2, 'MM2': UnitArea.MM2, 'YD2': UnitArea.YD2}

_unhashable_values_ (kittycad.models.unit_area.UnitArea attribute)

_value2member_map_ (kittycad.models.unit_area.UnitArea attribute)

{'cm2': UnitArea.CM2, 'dm2': UnitArea.DM2, 'ft2': UnitArea.FT2, 'in2': UnitArea.IN2, 'km2': UnitArea.KM2, 'm2': UnitArea.M2, 'mm2': UnitArea.MM2, 'yd2': UnitArea.YD2}

:py:obj:`__init__ <kittycad.models.unit_area.UnitArea.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_area.UnitArea.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_area.UnitArea.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_area.UnitArea.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_area.UnitArea.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_area.UnitArea.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_area.UnitArea.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_area.UnitArea.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_area.UnitArea.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_area.UnitArea.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_area.UnitArea.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_area.UnitArea.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_area.UnitArea.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_area.UnitArea.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_area.UnitArea.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.unit_area.UnitArea.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.unit_area.UnitArea.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_area.UnitArea.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_area.UnitArea.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_area.UnitArea.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_area.UnitArea.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_area.UnitArea.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_area.UnitArea.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_area.UnitArea.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_area.UnitArea.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_area.UnitArea.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_area.UnitArea.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_area.UnitArea.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_area.UnitArea.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_area.UnitArea.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_area.UnitArea.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_area.UnitArea.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_area.UnitArea.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_area.UnitArea.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_area.UnitArea.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_area.UnitArea.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_area.UnitArea.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_area.UnitArea.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_area.UnitArea.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_area.UnitArea.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_area.UnitArea.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_area.UnitArea.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_area.UnitArea.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_area.UnitArea.zfill>`\ \(width\, \/\)

CM2

//en.wikipedia.org/wiki/Square_decimetre>

DM2

//en.wikipedia.org/wiki/Square_foot>

FT2

//en.wikipedia.org/wiki/Square_inch>

IN2

//en.wikipedia.org/wiki/Square_kilometre>

KM2

//en.wikipedia.org/wiki/Square_metre>

M2

//en.wikipedia.org/wiki/Square_millimetre>

MM2

//en.wikipedia.org/wiki/Square_mile>

YD2

UnitAreaConversion([completed_at, ...])

:py:obj:`UnitAreaConversion <kittycad.models.unit_area_conversion.UnitAreaConversion>`\ \(\[completed\_at\, ...\]\)

UnitAreaConversion (class in kittycad.models.unit_area_conversion)

UnitAreaConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__delitem__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__dict__ (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_area_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitAreaConversion.to_dict>, 'from_dict': <classmethod(<function UnitAreaConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitAreaConversion.__getitem__>, '__setitem__': <function UnitAreaConversion.__setitem__>, '__delitem__': <function UnitAreaConversion.__delitem__>, '__contains__': <function UnitAreaConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitAreaConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitAreaConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_area.UnitArea], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitAreaConversion.__repr__>, '__eq__': <function UnitAreaConversion.__eq__>, '__ne__': <function UnitAreaConversion.__ne__>, '__lt__': <function UnitAreaConversion.__lt__>, '__le__': <function UnitAreaConversion.__le__>, '__gt__': <function UnitAreaConversion.__gt__>, '__ge__': <function UnitAreaConversion.__ge__>, '__hash__': None, '__init__': <function UnitAreaConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__ge__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__getitem__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__gt__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__hash__ (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

__init__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

UnitAreaConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__lt__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__module__ (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

__ne__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__repr__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

__setitem__() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

completed_at (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

created_at (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

error (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

from_dict() (kittycad.models.unit_area_conversion.UnitAreaConversion class method)

id (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

input (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

input_unit (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

output (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

output_unit (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

started_at (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

status (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

to_dict() (kittycad.models.unit_area_conversion.UnitAreaConversion method)

updated_at (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

user_id (kittycad.models.unit_area_conversion.UnitAreaConversion attribute)

Method generated by attrs for class UnitAreaConversion.

rtype

TypeVar(HF, bound= UnitAreaConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_area_conversion.UnitAreaConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

UnitCurrent(value[, names, module, ...])

The valid types of current units.

:py:obj:`UnitCurrent <kittycad.models.unit_current.UnitCurrent>`\ \(value\[\, names\, module\, ...\]\)

UnitCurrent(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

MICROAMPERES (kittycad.models.unit_current.UnitCurrent attribute)

docstring of kittycad.models.unit_current.UnitCurrent.MICROAMPERES

MILLIAMPERES (kittycad.models.unit_current.UnitCurrent attribute)

docstring of kittycad.models.unit_current.UnitCurrent.MILLIAMPERES

NANOAMPERES (kittycad.models.unit_current.UnitCurrent attribute)

__annotations__ (kittycad.models.unit_current.UnitCurrent attribute)

__contains__() (kittycad.models.unit_current.UnitCurrent method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_current', '__doc__': 'The valid types of current units.', '__str__': <function UnitCurrent.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['AMPERES', 'MICROAMPERES', 'MILLIAMPERES', 'NANOAMPERES'], '_member_map_': {'AMPERES': <UnitCurrent.AMPERES: 'amperes'>, 'MICROAMPERES': <UnitCurrent.MICROAMPERES: 'microamperes'>, 'MILLIAMPERES': <UnitCurrent.MILLIAMPERES: 'milliamperes'>, 'NANOAMPERES': <UnitCurrent.NANOAMPERES: 'nanoamperes'>}, '_value2member_map_': {'amperes': <UnitCurrent.AMPERES: 'amperes'>, 'microamperes': <UnitCurrent.MICROAMPERES: 'microamperes'>, 'milliamperes': <UnitCurrent.MILLIAMPERES: 'milliamperes'>, 'nanoamperes': <UnitCurrent.NANOAMPERES: 'nanoamperes'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitCurrent' objects>, '__weakref__': <attribute '__weakref__' of 'UnitCurrent' objects>, 'AMPERES': <UnitCurrent.AMPERES: 'amperes'>, 'MICROAMPERES': <UnitCurrent.MICROAMPERES: 'microamperes'>, 'MILLIAMPERES': <UnitCurrent.MILLIAMPERES: 'milliamperes'>, 'NANOAMPERES': <UnitCurrent.NANOAMPERES: 'nanoamperes'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_current.UnitCurrent method)

__getnewargs__() (kittycad.models.unit_current.UnitCurrent method)

__reduce_ex__() (kittycad.models.unit_current.UnitCurrent method)

_generate_next_value_() (kittycad.models.unit_current.UnitCurrent method)

_member_map_ (kittycad.models.unit_current.UnitCurrent attribute)

{'AMPERES': UnitCurrent.AMPERES, 'MICROAMPERES': UnitCurrent.MICROAMPERES, 'MILLIAMPERES': UnitCurrent.MILLIAMPERES, 'NANOAMPERES': UnitCurrent.NANOAMPERES}

_member_names_ (kittycad.models.unit_current.UnitCurrent attribute)

_member_type_ (kittycad.models.unit_current.UnitCurrent attribute)

_new_member_() (kittycad.models.unit_current.UnitCurrent method)

_unhashable_values_ (kittycad.models.unit_current.UnitCurrent attribute)

_value2member_map_ (kittycad.models.unit_current.UnitCurrent attribute)

{'amperes': UnitCurrent.AMPERES, 'microamperes': UnitCurrent.MICROAMPERES, 'milliamperes': UnitCurrent.MILLIAMPERES, 'nanoamperes': UnitCurrent.NANOAMPERES}

_value_repr_() (kittycad.models.unit_current.UnitCurrent method)

isidentifier() (kittycad.models.unit_current.UnitCurrent method)

maketrans() (kittycad.models.unit_current.UnitCurrent static method)

removeprefix() (kittycad.models.unit_current.UnitCurrent method)

removesuffix() (kittycad.models.unit_current.UnitCurrent method)

:py:obj:`__init__ <kittycad.models.unit_current.UnitCurrent.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_current.UnitCurrent.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_current.UnitCurrent.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_current.UnitCurrent.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_current.UnitCurrent.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_current.UnitCurrent.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_current.UnitCurrent.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_current.UnitCurrent.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_current.UnitCurrent.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_current.UnitCurrent.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_current.UnitCurrent.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_current.UnitCurrent.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_current.UnitCurrent.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_current.UnitCurrent.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_current.UnitCurrent.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_current.UnitCurrent.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_current.UnitCurrent.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_current.UnitCurrent.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_current.UnitCurrent.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_current.UnitCurrent.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_current.UnitCurrent.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_current.UnitCurrent.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_current.UnitCurrent.lower>`\ \(\)

:py:obj:`partition <kittycad.models.unit_current.UnitCurrent.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_current.UnitCurrent.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_current.UnitCurrent.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_current.UnitCurrent.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_current.UnitCurrent.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_current.UnitCurrent.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_current.UnitCurrent.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_current.UnitCurrent.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_current.UnitCurrent.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.unit_current.UnitCurrent.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_current.UnitCurrent.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_current.UnitCurrent.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_current.UnitCurrent.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_current.UnitCurrent.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_current.UnitCurrent.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_current.UnitCurrent.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_current.UnitCurrent.zfill>`\ \(width\, \/\)

AMPERES

//en.wikipedia.org/wiki/Microampere>

MICROAMPERES

//en.wikipedia.org/wiki/Milliampere>

MILLIAMPERES

//en.wikipedia.org/wiki/Nanoampere>

NANOAMPERES

UnitCurrentConversion([completed_at, ...])

UnitCurrentConversion (class in kittycad.models.unit_current_conversion)

UnitCurrentConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.unit_current_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitCurrentConversion.to_dict>, 'from_dict': <classmethod(<function UnitCurrentConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitCurrentConversion.__getitem__>, '__setitem__': <function UnitCurrentConversion.__setitem__>, '__delitem__': <function UnitCurrentConversion.__delitem__>, '__contains__': <function UnitCurrentConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitCurrentConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitCurrentConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_current.UnitCurrent], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitCurrentConversion.__repr__>, '__eq__': <function UnitCurrentConversion.__eq__>, '__ne__': <function UnitCurrentConversion.__ne__>, '__lt__': <function UnitCurrentConversion.__lt__>, '__le__': <function UnitCurrentConversion.__le__>, '__gt__': <function UnitCurrentConversion.__gt__>, '__ge__': <function UnitCurrentConversion.__ge__>, '__hash__': None, '__init__': <function UnitCurrentConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

__ge__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

__gt__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

UnitCurrentConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

__lt__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

__ne__() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

error (kittycad.models.unit_current_conversion.UnitCurrentConversion attribute)

from_dict() (kittycad.models.unit_current_conversion.UnitCurrentConversion class method)

id (kittycad.models.unit_current_conversion.UnitCurrentConversion attribute)

input (kittycad.models.unit_current_conversion.UnitCurrentConversion attribute)

output (kittycad.models.unit_current_conversion.UnitCurrentConversion attribute)

status (kittycad.models.unit_current_conversion.UnitCurrentConversion attribute)

to_dict() (kittycad.models.unit_current_conversion.UnitCurrentConversion method)

Method generated by attrs for class UnitCurrentConversion.

rtype

TypeVar(JD, bound= UnitCurrentConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_current_conversion.UnitCurrentConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``JD``, bound= UnitCurrentConversion)

UnitDensity(value[, names, module, ...])

The valid types for density units.

:py:obj:`UnitDensity <kittycad.models.unit_density.UnitDensity>`\ \(value\[\, names\, module\, ...\]\)

UnitDensity(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.unit_density.UnitDensity attribute)

__contains__() (kittycad.models.unit_density.UnitDensity method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_density', '__doc__': 'The valid types for density units.', '__str__': <function UnitDensity.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['LB_FT3', 'KG_M3'], '_member_map_': {'LB_FT3': <UnitDensity.LB_FT3: 'lb:ft3'>, 'KG_M3': <UnitDensity.KG_M3: 'kg:m3'>}, '_value2member_map_': {'lb:ft3': <UnitDensity.LB_FT3: 'lb:ft3'>, 'kg:m3': <UnitDensity.KG_M3: 'kg:m3'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitDensity' objects>, '__weakref__': <attribute '__weakref__' of 'UnitDensity' objects>, 'LB_FT3': <UnitDensity.LB_FT3: 'lb:ft3'>, 'KG_M3': <UnitDensity.KG_M3: 'kg:m3'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_density.UnitDensity method)

__getnewargs__() (kittycad.models.unit_density.UnitDensity method)

__reduce_ex__() (kittycad.models.unit_density.UnitDensity method)

_generate_next_value_() (kittycad.models.unit_density.UnitDensity method)

_member_map_ (kittycad.models.unit_density.UnitDensity attribute)

_member_names_ (kittycad.models.unit_density.UnitDensity attribute)

_member_type_ (kittycad.models.unit_density.UnitDensity attribute)

_new_member_() (kittycad.models.unit_density.UnitDensity method)

_unhashable_values_ (kittycad.models.unit_density.UnitDensity attribute)

_value2member_map_ (kittycad.models.unit_density.UnitDensity attribute)

_value_repr_() (kittycad.models.unit_density.UnitDensity method)

isidentifier() (kittycad.models.unit_density.UnitDensity method)

maketrans() (kittycad.models.unit_density.UnitDensity static method)

removeprefix() (kittycad.models.unit_density.UnitDensity method)

removesuffix() (kittycad.models.unit_density.UnitDensity method)

:py:obj:`__init__ <kittycad.models.unit_density.UnitDensity.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_density.UnitDensity.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_density.UnitDensity.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_density.UnitDensity.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_density.UnitDensity.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_density.UnitDensity.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_density.UnitDensity.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_density.UnitDensity.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_density.UnitDensity.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_density.UnitDensity.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_density.UnitDensity.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_density.UnitDensity.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_density.UnitDensity.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_density.UnitDensity.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_density.UnitDensity.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_density.UnitDensity.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_density.UnitDensity.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_density.UnitDensity.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_density.UnitDensity.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_density.UnitDensity.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_density.UnitDensity.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_density.UnitDensity.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_density.UnitDensity.lower>`\ \(\)

:py:obj:`partition <kittycad.models.unit_density.UnitDensity.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_density.UnitDensity.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_density.UnitDensity.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_density.UnitDensity.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_density.UnitDensity.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_density.UnitDensity.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_density.UnitDensity.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_density.UnitDensity.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_density.UnitDensity.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.unit_density.UnitDensity.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_density.UnitDensity.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_density.UnitDensity.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_density.UnitDensity.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_density.UnitDensity.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_density.UnitDensity.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_density.UnitDensity.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_density.UnitDensity.zfill>`\ \(width\, \/\)

UnitEnergy(value[, names, module, qualname, ...])

The valid types of energy units.

:py:obj:`UnitEnergy <kittycad.models.unit_energy.UnitEnergy>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitEnergy(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

ELECTRONVOLTS (kittycad.models.unit_energy.UnitEnergy attribute)

docstring of kittycad.models.unit_energy.UnitEnergy.ELECTRONVOLTS

docstring of kittycad.models.unit_energy.UnitEnergy.KILOCALORIES

KILOWATT_HOURS (kittycad.models.unit_energy.UnitEnergy attribute)

docstring of kittycad.models.unit_energy.UnitEnergy.KILOWATT_HOURS

__annotations__ (kittycad.models.unit_energy.UnitEnergy attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_energy', '__doc__': 'The valid types of energy units.', '__str__': <function UnitEnergy.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['BTU', 'ELECTRONVOLTS', 'JOULES', 'KILOCALORIES', 'KILOWATT_HOURS', 'WATT_HOURS'], '_member_map_': {'BTU': <UnitEnergy.BTU: 'btu'>, 'ELECTRONVOLTS': <UnitEnergy.ELECTRONVOLTS: 'electronvolts'>, 'JOULES': <UnitEnergy.JOULES: 'joules'>, 'KILOCALORIES': <UnitEnergy.KILOCALORIES: 'kilocalories'>, 'KILOWATT_HOURS': <UnitEnergy.KILOWATT_HOURS: 'kilowatt_hours'>, 'WATT_HOURS': <UnitEnergy.WATT_HOURS: 'watt_hours'>}, '_value2member_map_': {'btu': <UnitEnergy.BTU: 'btu'>, 'electronvolts': <UnitEnergy.ELECTRONVOLTS: 'electronvolts'>, 'joules': <UnitEnergy.JOULES: 'joules'>, 'kilocalories': <UnitEnergy.KILOCALORIES: 'kilocalories'>, 'kilowatt_hours': <UnitEnergy.KILOWATT_HOURS: 'kilowatt_hours'>, 'watt_hours': <UnitEnergy.WATT_HOURS: 'watt_hours'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitEnergy' objects>, '__weakref__': <attribute '__weakref__' of 'UnitEnergy' objects>, 'BTU': <UnitEnergy.BTU: 'btu'>, 'ELECTRONVOLTS': <UnitEnergy.ELECTRONVOLTS: 'electronvolts'>, 'JOULES': <UnitEnergy.JOULES: 'joules'>, 'KILOCALORIES': <UnitEnergy.KILOCALORIES: 'kilocalories'>, 'KILOWATT_HOURS': <UnitEnergy.KILOWATT_HOURS: 'kilowatt_hours'>, 'WATT_HOURS': <UnitEnergy.WATT_HOURS: 'watt_hours'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_energy.UnitEnergy method)

__getnewargs__() (kittycad.models.unit_energy.UnitEnergy method)

_generate_next_value_() (kittycad.models.unit_energy.UnitEnergy method)

{'BTU': UnitEnergy.BTU, 'ELECTRONVOLTS': UnitEnergy.ELECTRONVOLTS, 'JOULES': UnitEnergy.JOULES, 'KILOCALORIES': UnitEnergy.KILOCALORIES, 'KILOWATT_HOURS': UnitEnergy.KILOWATT_HOURS, 'WATT_HOURS': UnitEnergy.WATT_HOURS}

_member_names_ (kittycad.models.unit_energy.UnitEnergy attribute)

['BTU', 'ELECTRONVOLTS', 'JOULES', 'KILOCALORIES', 'KILOWATT_HOURS', 'WATT_HOURS']

_member_type_ (kittycad.models.unit_energy.UnitEnergy attribute)

_unhashable_values_ (kittycad.models.unit_energy.UnitEnergy attribute)

_value2member_map_ (kittycad.models.unit_energy.UnitEnergy attribute)

{'btu': UnitEnergy.BTU, 'electronvolts': UnitEnergy.ELECTRONVOLTS, 'joules': UnitEnergy.JOULES, 'kilocalories': UnitEnergy.KILOCALORIES, 'kilowatt_hours': UnitEnergy.KILOWATT_HOURS, 'watt_hours': UnitEnergy.WATT_HOURS}

maketrans() (kittycad.models.unit_energy.UnitEnergy static method)

:py:obj:`__init__ <kittycad.models.unit_energy.UnitEnergy.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_energy.UnitEnergy.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_energy.UnitEnergy.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_energy.UnitEnergy.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_energy.UnitEnergy.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_energy.UnitEnergy.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_energy.UnitEnergy.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_energy.UnitEnergy.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_energy.UnitEnergy.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_energy.UnitEnergy.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_energy.UnitEnergy.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_energy.UnitEnergy.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_energy.UnitEnergy.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_energy.UnitEnergy.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_energy.UnitEnergy.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_energy.UnitEnergy.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_energy.UnitEnergy.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_energy.UnitEnergy.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_energy.UnitEnergy.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_energy.UnitEnergy.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_energy.UnitEnergy.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_energy.UnitEnergy.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_energy.UnitEnergy.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_energy.UnitEnergy.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_energy.UnitEnergy.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_energy.UnitEnergy.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_energy.UnitEnergy.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_energy.UnitEnergy.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_energy.UnitEnergy.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_energy.UnitEnergy.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_energy.UnitEnergy.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_energy.UnitEnergy.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_energy.UnitEnergy.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_energy.UnitEnergy.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_energy.UnitEnergy.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_energy.UnitEnergy.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_energy.UnitEnergy.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_energy.UnitEnergy.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_energy.UnitEnergy.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_energy.UnitEnergy.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_energy.UnitEnergy.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_energy.UnitEnergy.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_energy.UnitEnergy.zfill>`\ \(width\, \/\)

BTU

//en.wikipedia.org/wiki/Electronvolt>

ELECTRONVOLTS

//en.wikipedia.org/wiki/Joule>

JOULES

//en.wikipedia.org/wiki/Kilocalorie>

KILOCALORIES

//en.wikipedia.org/wiki/Kilowatt-hour>

KILOWATT_HOURS

WATT_HOURS

UnitEnergyConversion([completed_at, ...])

UnitEnergyConversion (class in kittycad.models.unit_energy_conversion)

UnitEnergyConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_energy_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitEnergyConversion.to_dict>, 'from_dict': <classmethod(<function UnitEnergyConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitEnergyConversion.__getitem__>, '__setitem__': <function UnitEnergyConversion.__setitem__>, '__delitem__': <function UnitEnergyConversion.__delitem__>, '__contains__': <function UnitEnergyConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitEnergyConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitEnergyConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_energy.UnitEnergy], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitEnergyConversion.__repr__>, '__eq__': <function UnitEnergyConversion.__eq__>, '__ne__': <function UnitEnergyConversion.__ne__>, '__lt__': <function UnitEnergyConversion.__lt__>, '__le__': <function UnitEnergyConversion.__le__>, '__gt__': <function UnitEnergyConversion.__gt__>, '__ge__': <function UnitEnergyConversion.__ge__>, '__hash__': None, '__init__': <function UnitEnergyConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__ge__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__gt__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__hash__ (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

__init__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

UnitEnergyConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__lt__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__ne__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

__repr__() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

error (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

from_dict() (kittycad.models.unit_energy_conversion.UnitEnergyConversion class method)

id (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

input (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

output (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

status (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

to_dict() (kittycad.models.unit_energy_conversion.UnitEnergyConversion method)

user_id (kittycad.models.unit_energy_conversion.UnitEnergyConversion attribute)

Method generated by attrs for class UnitEnergyConversion.

rtype

TypeVar(RZ, bound= UnitEnergyConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_energy_conversion.UnitEnergyConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``RZ``, bound= UnitEnergyConversion)

UnitForce(value[, names, module, qualname, ...])

The valid types of force units.

:py:obj:`UnitForce <kittycad.models.unit_force.UnitForce>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitForce(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.unit_force.UnitForce attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_force', '__doc__': 'The valid types of force units.', '__str__': <function UnitForce.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['DYNES', 'KILOPONDS', 'MICRONEWTONS', 'MILLINEWTONS', 'NEWTONS', 'POUNDALS', 'POUNDS'], '_member_map_': {'DYNES': <UnitForce.DYNES: 'dynes'>, 'KILOPONDS': <UnitForce.KILOPONDS: 'kiloponds'>, 'MICRONEWTONS': <UnitForce.MICRONEWTONS: 'micronewtons'>, 'MILLINEWTONS': <UnitForce.MILLINEWTONS: 'millinewtons'>, 'NEWTONS': <UnitForce.NEWTONS: 'newtons'>, 'POUNDALS': <UnitForce.POUNDALS: 'poundals'>, 'POUNDS': <UnitForce.POUNDS: 'pounds'>}, '_value2member_map_': {'dynes': <UnitForce.DYNES: 'dynes'>, 'kiloponds': <UnitForce.KILOPONDS: 'kiloponds'>, 'micronewtons': <UnitForce.MICRONEWTONS: 'micronewtons'>, 'millinewtons': <UnitForce.MILLINEWTONS: 'millinewtons'>, 'newtons': <UnitForce.NEWTONS: 'newtons'>, 'poundals': <UnitForce.POUNDALS: 'poundals'>, 'pounds': <UnitForce.POUNDS: 'pounds'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitForce' objects>, '__weakref__': <attribute '__weakref__' of 'UnitForce' objects>, 'DYNES': <UnitForce.DYNES: 'dynes'>, 'KILOPONDS': <UnitForce.KILOPONDS: 'kiloponds'>, 'MICRONEWTONS': <UnitForce.MICRONEWTONS: 'micronewtons'>, 'MILLINEWTONS': <UnitForce.MILLINEWTONS: 'millinewtons'>, 'NEWTONS': <UnitForce.NEWTONS: 'newtons'>, 'POUNDALS': <UnitForce.POUNDALS: 'poundals'>, 'POUNDS': <UnitForce.POUNDS: 'pounds'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_force.UnitForce method)

_generate_next_value_() (kittycad.models.unit_force.UnitForce method)

{'DYNES': UnitForce.DYNES, 'KILOPONDS': UnitForce.KILOPONDS, 'MICRONEWTONS': UnitForce.MICRONEWTONS, 'MILLINEWTONS': UnitForce.MILLINEWTONS, 'NEWTONS': UnitForce.NEWTONS, 'POUNDALS': UnitForce.POUNDALS, 'POUNDS': UnitForce.POUNDS}

['DYNES', 'KILOPONDS', 'MICRONEWTONS', 'MILLINEWTONS', 'NEWTONS', 'POUNDALS', 'POUNDS']

_unhashable_values_ (kittycad.models.unit_force.UnitForce attribute)

_value2member_map_ (kittycad.models.unit_force.UnitForce attribute)

{'dynes': UnitForce.DYNES, 'kiloponds': UnitForce.KILOPONDS, 'micronewtons': UnitForce.MICRONEWTONS, 'millinewtons': UnitForce.MILLINEWTONS, 'newtons': UnitForce.NEWTONS, 'poundals': UnitForce.POUNDALS, 'pounds': UnitForce.POUNDS}

maketrans() (kittycad.models.unit_force.UnitForce static method)

:py:obj:`__init__ <kittycad.models.unit_force.UnitForce.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_force.UnitForce.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_force.UnitForce.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_force.UnitForce.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_force.UnitForce.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_force.UnitForce.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_force.UnitForce.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_force.UnitForce.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_force.UnitForce.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_force.UnitForce.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_force.UnitForce.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_force.UnitForce.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_force.UnitForce.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_force.UnitForce.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_force.UnitForce.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.unit_force.UnitForce.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.unit_force.UnitForce.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_force.UnitForce.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_force.UnitForce.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_force.UnitForce.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_force.UnitForce.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_force.UnitForce.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_force.UnitForce.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_force.UnitForce.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_force.UnitForce.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_force.UnitForce.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_force.UnitForce.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_force.UnitForce.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_force.UnitForce.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_force.UnitForce.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_force.UnitForce.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_force.UnitForce.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_force.UnitForce.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_force.UnitForce.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_force.UnitForce.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_force.UnitForce.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_force.UnitForce.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_force.UnitForce.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_force.UnitForce.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_force.UnitForce.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_force.UnitForce.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_force.UnitForce.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_force.UnitForce.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_force.UnitForce.zfill>`\ \(width\, \/\)

DYNES

//en.wikipedia.org/wiki/Kilopond>

KILOPONDS

//en.wikipedia.org/wiki/Newton_(unit)>

MICRONEWTONS

MILLINEWTONS

NEWTONS

//en.wikipedia.org/wiki/Poundal>

POUNDALS

//en.wikipedia.org/wiki/Pound_(force)>

POUNDS

UnitForceConversion([completed_at, ...])

:py:obj:`UnitForceConversion <kittycad.models.unit_force_conversion.UnitForceConversion>`\ \(\[completed\_at\, ...\]\)

UnitForceConversion (class in kittycad.models.unit_force_conversion)

UnitForceConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__delitem__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__dict__ (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_force_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitForceConversion.to_dict>, 'from_dict': <classmethod(<function UnitForceConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitForceConversion.__getitem__>, '__setitem__': <function UnitForceConversion.__setitem__>, '__delitem__': <function UnitForceConversion.__delitem__>, '__contains__': <function UnitForceConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitForceConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitForceConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_force.UnitForce], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitForceConversion.__repr__>, '__eq__': <function UnitForceConversion.__eq__>, '__ne__': <function UnitForceConversion.__ne__>, '__lt__': <function UnitForceConversion.__lt__>, '__le__': <function UnitForceConversion.__le__>, '__gt__': <function UnitForceConversion.__gt__>, '__ge__': <function UnitForceConversion.__ge__>, '__hash__': None, '__init__': <function UnitForceConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__ge__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__getitem__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__gt__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__hash__ (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

__init__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

UnitForceConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__lt__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__module__ (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

__ne__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__repr__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

__setitem__() (kittycad.models.unit_force_conversion.UnitForceConversion method)

created_at (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

error (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

from_dict() (kittycad.models.unit_force_conversion.UnitForceConversion class method)

id (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

input (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

input_unit (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

output (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

started_at (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

status (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

to_dict() (kittycad.models.unit_force_conversion.UnitForceConversion method)

updated_at (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

user_id (kittycad.models.unit_force_conversion.UnitForceConversion attribute)

Method generated by attrs for class UnitForceConversion.

rtype

TypeVar(BH, bound= UnitForceConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_force_conversion.UnitForceConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``BH``, bound= UnitForceConversion)

UnitFrequency(value[, names, module, ...])

The valid types of frequency units.

:py:obj:`UnitFrequency <kittycad.models.unit_frequency.UnitFrequency>`\ \(value\[\, names\, module\, ...\]\)

UnitFrequency(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

GIGAHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.GIGAHERTZ

KILOHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.KILOHERTZ

MEGAHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.MEGAHERTZ

MICROHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.MICROHERTZ

MILLIHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.MILLIHERTZ

NANOHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

docstring of kittycad.models.unit_frequency.UnitFrequency.NANOHERTZ

TERAHERTZ (kittycad.models.unit_frequency.UnitFrequency attribute)

__annotations__ (kittycad.models.unit_frequency.UnitFrequency attribute)

__contains__() (kittycad.models.unit_frequency.UnitFrequency method)

__dict__ (kittycad.models.unit_frequency.UnitFrequency attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_frequency', '__doc__': 'The valid types of frequency units.', '__str__': <function UnitFrequency.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['GIGAHERTZ', 'HERTZ', 'KILOHERTZ', 'MEGAHERTZ', 'MICROHERTZ', 'MILLIHERTZ', 'NANOHERTZ', 'TERAHERTZ'], '_member_map_': {'GIGAHERTZ': <UnitFrequency.GIGAHERTZ: 'gigahertz'>, 'HERTZ': <UnitFrequency.HERTZ: 'hertz'>, 'KILOHERTZ': <UnitFrequency.KILOHERTZ: 'kilohertz'>, 'MEGAHERTZ': <UnitFrequency.MEGAHERTZ: 'megahertz'>, 'MICROHERTZ': <UnitFrequency.MICROHERTZ: 'microhertz'>, 'MILLIHERTZ': <UnitFrequency.MILLIHERTZ: 'millihertz'>, 'NANOHERTZ': <UnitFrequency.NANOHERTZ: 'nanohertz'>, 'TERAHERTZ': <UnitFrequency.TERAHERTZ: 'terahertz'>}, '_value2member_map_': {'gigahertz': <UnitFrequency.GIGAHERTZ: 'gigahertz'>, 'hertz': <UnitFrequency.HERTZ: 'hertz'>, 'kilohertz': <UnitFrequency.KILOHERTZ: 'kilohertz'>, 'megahertz': <UnitFrequency.MEGAHERTZ: 'megahertz'>, 'microhertz': <UnitFrequency.MICROHERTZ: 'microhertz'>, 'millihertz': <UnitFrequency.MILLIHERTZ: 'millihertz'>, 'nanohertz': <UnitFrequency.NANOHERTZ: 'nanohertz'>, 'terahertz': <UnitFrequency.TERAHERTZ: 'terahertz'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitFrequency' objects>, '__weakref__': <attribute '__weakref__' of 'UnitFrequency' objects>, 'GIGAHERTZ': <UnitFrequency.GIGAHERTZ: 'gigahertz'>, 'HERTZ': <UnitFrequency.HERTZ: 'hertz'>, 'KILOHERTZ': <UnitFrequency.KILOHERTZ: 'kilohertz'>, 'MEGAHERTZ': <UnitFrequency.MEGAHERTZ: 'megahertz'>, 'MICROHERTZ': <UnitFrequency.MICROHERTZ: 'microhertz'>, 'MILLIHERTZ': <UnitFrequency.MILLIHERTZ: 'millihertz'>, 'NANOHERTZ': <UnitFrequency.NANOHERTZ: 'nanohertz'>, 'TERAHERTZ': <UnitFrequency.TERAHERTZ: 'terahertz'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__format__() (kittycad.models.unit_frequency.UnitFrequency method)

__getattribute__() (kittycad.models.unit_frequency.UnitFrequency method)

__getitem__() (kittycad.models.unit_frequency.UnitFrequency method)

__getnewargs__() (kittycad.models.unit_frequency.UnitFrequency method)

__hash__() (kittycad.models.unit_frequency.UnitFrequency method)

__init__() (kittycad.models.unit_frequency.UnitFrequency method)

__iter__() (kittycad.models.unit_frequency.UnitFrequency method)

__module__ (kittycad.models.unit_frequency.UnitFrequency attribute)

__reduce_ex__() (kittycad.models.unit_frequency.UnitFrequency method)

__repr__() (kittycad.models.unit_frequency.UnitFrequency method)

__rmod__() (kittycad.models.unit_frequency.UnitFrequency method)

__rmul__() (kittycad.models.unit_frequency.UnitFrequency method)

__sizeof__() (kittycad.models.unit_frequency.UnitFrequency method)

_generate_next_value_() (kittycad.models.unit_frequency.UnitFrequency method)

_member_map_ (kittycad.models.unit_frequency.UnitFrequency attribute)

{'GIGAHERTZ': UnitFrequency.GIGAHERTZ, 'HERTZ': UnitFrequency.HERTZ, 'KILOHERTZ': UnitFrequency.KILOHERTZ, 'MEGAHERTZ': UnitFrequency.MEGAHERTZ, 'MICROHERTZ': UnitFrequency.MICROHERTZ, 'MILLIHERTZ': UnitFrequency.MILLIHERTZ, 'NANOHERTZ': UnitFrequency.NANOHERTZ, 'TERAHERTZ': UnitFrequency.TERAHERTZ}

_member_names_ (kittycad.models.unit_frequency.UnitFrequency attribute)

['GIGAHERTZ', 'HERTZ', 'KILOHERTZ', 'MEGAHERTZ', 'MICROHERTZ', 'MILLIHERTZ', 'NANOHERTZ', 'TERAHERTZ']

_member_type_ (kittycad.models.unit_frequency.UnitFrequency attribute)

_new_member_() (kittycad.models.unit_frequency.UnitFrequency method)

_unhashable_values_ (kittycad.models.unit_frequency.UnitFrequency attribute)

_use_args_ (kittycad.models.unit_frequency.UnitFrequency attribute)

_value2member_map_ (kittycad.models.unit_frequency.UnitFrequency attribute)

{'gigahertz': UnitFrequency.GIGAHERTZ, 'hertz': UnitFrequency.HERTZ, 'kilohertz': UnitFrequency.KILOHERTZ, 'megahertz': UnitFrequency.MEGAHERTZ, 'microhertz': UnitFrequency.MICROHERTZ, 'millihertz': UnitFrequency.MILLIHERTZ, 'nanohertz': UnitFrequency.NANOHERTZ, 'terahertz': UnitFrequency.TERAHERTZ}

_value_repr_() (kittycad.models.unit_frequency.UnitFrequency method)

capitalize() (kittycad.models.unit_frequency.UnitFrequency method)

casefold() (kittycad.models.unit_frequency.UnitFrequency method)

endswith() (kittycad.models.unit_frequency.UnitFrequency method)

expandtabs() (kittycad.models.unit_frequency.UnitFrequency method)

format_map() (kittycad.models.unit_frequency.UnitFrequency method)

isdecimal() (kittycad.models.unit_frequency.UnitFrequency method)

isidentifier() (kittycad.models.unit_frequency.UnitFrequency method)

isnumeric() (kittycad.models.unit_frequency.UnitFrequency method)

isprintable() (kittycad.models.unit_frequency.UnitFrequency method)

maketrans() (kittycad.models.unit_frequency.UnitFrequency static method)

partition() (kittycad.models.unit_frequency.UnitFrequency method)

removeprefix() (kittycad.models.unit_frequency.UnitFrequency method)

removesuffix() (kittycad.models.unit_frequency.UnitFrequency method)

rpartition() (kittycad.models.unit_frequency.UnitFrequency method)

splitlines() (kittycad.models.unit_frequency.UnitFrequency method)

startswith() (kittycad.models.unit_frequency.UnitFrequency method)

swapcase() (kittycad.models.unit_frequency.UnitFrequency method)

translate() (kittycad.models.unit_frequency.UnitFrequency method)

:py:obj:`__init__ <kittycad.models.unit_frequency.UnitFrequency.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`casefold <kittycad.models.unit_frequency.UnitFrequency.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_frequency.UnitFrequency.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_frequency.UnitFrequency.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_frequency.UnitFrequency.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_frequency.UnitFrequency.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_frequency.UnitFrequency.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_frequency.UnitFrequency.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_frequency.UnitFrequency.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_frequency.UnitFrequency.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_frequency.UnitFrequency.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_frequency.UnitFrequency.isascii>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_frequency.UnitFrequency.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_frequency.UnitFrequency.islower>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_frequency.UnitFrequency.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_frequency.UnitFrequency.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_frequency.UnitFrequency.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_frequency.UnitFrequency.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_frequency.UnitFrequency.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_frequency.UnitFrequency.lower>`\ \(\)

:py:obj:`partition <kittycad.models.unit_frequency.UnitFrequency.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_frequency.UnitFrequency.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_frequency.UnitFrequency.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_frequency.UnitFrequency.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_frequency.UnitFrequency.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_frequency.UnitFrequency.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_frequency.UnitFrequency.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_frequency.UnitFrequency.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_frequency.UnitFrequency.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.unit_frequency.UnitFrequency.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_frequency.UnitFrequency.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`swapcase <kittycad.models.unit_frequency.UnitFrequency.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_frequency.UnitFrequency.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_frequency.UnitFrequency.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_frequency.UnitFrequency.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_frequency.UnitFrequency.zfill>`\ \(width\, \/\)

GIGAHERTZ

//en.wikipedia.org/wiki/Hertz>

HERTZ

KILOHERTZ

MEGAHERTZ

MICROHERTZ

MILLIHERTZ

NANOHERTZ

TERAHERTZ

UnitFrequencyConversion([completed_at, ...])

UnitFrequencyConversion (class in kittycad.models.unit_frequency_conversion)

UnitFrequencyConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.unit_frequency_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitFrequencyConversion.to_dict>, 'from_dict': <classmethod(<function UnitFrequencyConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitFrequencyConversion.__getitem__>, '__setitem__': <function UnitFrequencyConversion.__setitem__>, '__delitem__': <function UnitFrequencyConversion.__delitem__>, '__contains__': <function UnitFrequencyConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitFrequencyConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitFrequencyConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_frequency.UnitFrequency], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitFrequencyConversion.__repr__>, '__eq__': <function UnitFrequencyConversion.__eq__>, '__ne__': <function UnitFrequencyConversion.__ne__>, '__lt__': <function UnitFrequencyConversion.__lt__>, '__le__': <function UnitFrequencyConversion.__le__>, '__gt__': <function UnitFrequencyConversion.__gt__>, '__ge__': <function UnitFrequencyConversion.__ge__>, '__hash__': None, '__init__': <function UnitFrequencyConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

UnitFrequencyConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

from_dict() (kittycad.models.unit_frequency_conversion.UnitFrequencyConversion class method)

id (kittycad.models.unit_frequency_conversion.UnitFrequencyConversion attribute)

Method generated by attrs for class UnitFrequencyConversion.

rtype

TypeVar(SX, bound= UnitFrequencyConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_frequency_conversion.UnitFrequencyConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``SX``, bound= UnitFrequencyConversion)

UnitLength(value[, names, module, qualname, ...])

The valid types of length units.

:py:obj:`UnitLength <kittycad.models.unit_length.UnitLength>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitLength(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.unit_length.UnitLength attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_length', '__doc__': 'The valid types of length units.', '__str__': <function UnitLength.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CM', 'FT', 'IN', 'M', 'MM', 'YD'], '_member_map_': {'CM': <UnitLength.CM: 'cm'>, 'FT': <UnitLength.FT: 'ft'>, 'IN': <UnitLength.IN: 'in'>, 'M': <UnitLength.M: 'm'>, 'MM': <UnitLength.MM: 'mm'>, 'YD': <UnitLength.YD: 'yd'>}, '_value2member_map_': {'cm': <UnitLength.CM: 'cm'>, 'ft': <UnitLength.FT: 'ft'>, 'in': <UnitLength.IN: 'in'>, 'm': <UnitLength.M: 'm'>, 'mm': <UnitLength.MM: 'mm'>, 'yd': <UnitLength.YD: 'yd'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitLength' objects>, '__weakref__': <attribute '__weakref__' of 'UnitLength' objects>, 'CM': <UnitLength.CM: 'cm'>, 'FT': <UnitLength.FT: 'ft'>, 'IN': <UnitLength.IN: 'in'>, 'M': <UnitLength.M: 'm'>, 'MM': <UnitLength.MM: 'mm'>, 'YD': <UnitLength.YD: 'yd'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_length.UnitLength method)

__getnewargs__() (kittycad.models.unit_length.UnitLength method)

_generate_next_value_() (kittycad.models.unit_length.UnitLength method)

{'CM': UnitLength.CM, 'FT': UnitLength.FT, 'IN': UnitLength.IN, 'M': UnitLength.M, 'MM': UnitLength.MM, 'YD': UnitLength.YD}

_member_names_ (kittycad.models.unit_length.UnitLength attribute)

_member_type_ (kittycad.models.unit_length.UnitLength attribute)

_unhashable_values_ (kittycad.models.unit_length.UnitLength attribute)

_value2member_map_ (kittycad.models.unit_length.UnitLength attribute)

{'cm': UnitLength.CM, 'ft': UnitLength.FT, 'in': UnitLength.IN, 'm': UnitLength.M, 'mm': UnitLength.MM, 'yd': UnitLength.YD}

maketrans() (kittycad.models.unit_length.UnitLength static method)

:py:obj:`__init__ <kittycad.models.unit_length.UnitLength.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_length.UnitLength.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_length.UnitLength.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_length.UnitLength.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_length.UnitLength.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_length.UnitLength.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_length.UnitLength.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_length.UnitLength.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_length.UnitLength.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_length.UnitLength.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_length.UnitLength.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_length.UnitLength.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_length.UnitLength.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_length.UnitLength.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_length.UnitLength.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_length.UnitLength.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_length.UnitLength.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_length.UnitLength.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_length.UnitLength.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_length.UnitLength.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_length.UnitLength.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_length.UnitLength.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_length.UnitLength.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_length.UnitLength.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_length.UnitLength.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_length.UnitLength.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_length.UnitLength.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_length.UnitLength.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_length.UnitLength.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_length.UnitLength.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_length.UnitLength.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_length.UnitLength.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_length.UnitLength.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_length.UnitLength.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_length.UnitLength.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_length.UnitLength.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_length.UnitLength.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_length.UnitLength.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_length.UnitLength.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_length.UnitLength.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_length.UnitLength.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_length.UnitLength.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_length.UnitLength.zfill>`\ \(width\, \/\)

CM

//en.wikipedia.org/wiki/Foot_(unit)>

FT

//en.wikipedia.org/wiki/Inch>

IN

//en.wikipedia.org/wiki/Metre>

M

//en.wikipedia.org/wiki/Millimetre>

MM

//en.wikipedia.org/wiki/Yard>

YD

UnitLengthConversion([completed_at, ...])

UnitLengthConversion (class in kittycad.models.unit_length_conversion)

UnitLengthConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_length_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitLengthConversion.to_dict>, 'from_dict': <classmethod(<function UnitLengthConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitLengthConversion.__getitem__>, '__setitem__': <function UnitLengthConversion.__setitem__>, '__delitem__': <function UnitLengthConversion.__delitem__>, '__contains__': <function UnitLengthConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitLengthConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitLengthConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_length.UnitLength], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitLengthConversion.__repr__>, '__eq__': <function UnitLengthConversion.__eq__>, '__ne__': <function UnitLengthConversion.__ne__>, '__lt__': <function UnitLengthConversion.__lt__>, '__le__': <function UnitLengthConversion.__le__>, '__gt__': <function UnitLengthConversion.__gt__>, '__ge__': <function UnitLengthConversion.__ge__>, '__hash__': None, '__init__': <function UnitLengthConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__ge__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__gt__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__hash__ (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

__init__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

UnitLengthConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__lt__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__ne__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

__repr__() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

error (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

from_dict() (kittycad.models.unit_length_conversion.UnitLengthConversion class method)

id (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

input (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

output (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

status (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

to_dict() (kittycad.models.unit_length_conversion.UnitLengthConversion method)

user_id (kittycad.models.unit_length_conversion.UnitLengthConversion attribute)

Method generated by attrs for class UnitLengthConversion.

rtype

TypeVar(CN, bound= UnitLengthConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_length_conversion.UnitLengthConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``CN``, bound= UnitLengthConversion)

UnitMass(value[, names, module, qualname, ...])

The valid types of mass units.

:py:obj:`UnitMass <kittycad.models.unit_mass.UnitMass>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitMass(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_mass', '__doc__': 'The valid types of mass units.', '__str__': <function UnitMass.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['G', 'KG', 'LB'], '_member_map_': {'G': <UnitMass.G: 'g'>, 'KG': <UnitMass.KG: 'kg'>, 'LB': <UnitMass.LB: 'lb'>}, '_value2member_map_': {'g': <UnitMass.G: 'g'>, 'kg': <UnitMass.KG: 'kg'>, 'lb': <UnitMass.LB: 'lb'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitMass' objects>, '__weakref__': <attribute '__weakref__' of 'UnitMass' objects>, 'G': <UnitMass.G: 'g'>, 'KG': <UnitMass.KG: 'kg'>, 'LB': <UnitMass.LB: 'lb'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

_generate_next_value_() (kittycad.models.unit_mass.UnitMass method)

_unhashable_values_ (kittycad.models.unit_mass.UnitMass attribute)

_value2member_map_ (kittycad.models.unit_mass.UnitMass attribute)

:py:obj:`__init__ <kittycad.models.unit_mass.UnitMass.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_mass.UnitMass.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_mass.UnitMass.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_mass.UnitMass.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_mass.UnitMass.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_mass.UnitMass.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_mass.UnitMass.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_mass.UnitMass.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_mass.UnitMass.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_mass.UnitMass.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_mass.UnitMass.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_mass.UnitMass.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_mass.UnitMass.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_mass.UnitMass.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_mass.UnitMass.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.unit_mass.UnitMass.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.unit_mass.UnitMass.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_mass.UnitMass.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_mass.UnitMass.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_mass.UnitMass.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_mass.UnitMass.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_mass.UnitMass.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_mass.UnitMass.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_mass.UnitMass.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_mass.UnitMass.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_mass.UnitMass.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_mass.UnitMass.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_mass.UnitMass.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_mass.UnitMass.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_mass.UnitMass.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_mass.UnitMass.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_mass.UnitMass.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_mass.UnitMass.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_mass.UnitMass.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_mass.UnitMass.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_mass.UnitMass.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_mass.UnitMass.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_mass.UnitMass.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_mass.UnitMass.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_mass.UnitMass.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_mass.UnitMass.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_mass.UnitMass.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_mass.UnitMass.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_mass.UnitMass.zfill>`\ \(width\, \/\)

G

//en.wikipedia.org/wiki/Kilogram>

KG

//en.wikipedia.org/wiki/Pound_(mass)>

LB

UnitMassConversion([completed_at, ...])

:py:obj:`UnitMassConversion <kittycad.models.unit_mass_conversion.UnitMassConversion>`\ \(\[completed\_at\, ...\]\)

UnitMassConversion (class in kittycad.models.unit_mass_conversion)

UnitMassConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__delitem__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__dict__ (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_mass_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitMassConversion.to_dict>, 'from_dict': <classmethod(<function UnitMassConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitMassConversion.__getitem__>, '__setitem__': <function UnitMassConversion.__setitem__>, '__delitem__': <function UnitMassConversion.__delitem__>, '__contains__': <function UnitMassConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitMassConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitMassConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_mass.UnitMass], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitMassConversion.__repr__>, '__eq__': <function UnitMassConversion.__eq__>, '__ne__': <function UnitMassConversion.__ne__>, '__lt__': <function UnitMassConversion.__lt__>, '__le__': <function UnitMassConversion.__le__>, '__gt__': <function UnitMassConversion.__gt__>, '__ge__': <function UnitMassConversion.__ge__>, '__hash__': None, '__init__': <function UnitMassConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__ge__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__getitem__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__gt__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__hash__ (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

__init__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

UnitMassConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__lt__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__module__ (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

__ne__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__repr__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

__setitem__() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

completed_at (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

created_at (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

error (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

from_dict() (kittycad.models.unit_mass_conversion.UnitMassConversion class method)

id (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

input (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

input_unit (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

output (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

output_unit (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

started_at (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

status (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

to_dict() (kittycad.models.unit_mass_conversion.UnitMassConversion method)

updated_at (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

user_id (kittycad.models.unit_mass_conversion.UnitMassConversion attribute)

Method generated by attrs for class UnitMassConversion.

rtype

TypeVar(GS, bound= UnitMassConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_mass_conversion.UnitMassConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

UnitPower(value[, names, module, qualname, ...])

The valid types of power units.

:py:obj:`UnitPower <kittycad.models.unit_power.UnitPower>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitPower(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

docstring of kittycad.models.unit_power.UnitPower.BTU_PER_MINUTE

METRIC_HORSEPOWER (kittycad.models.unit_power.UnitPower attribute)

docstring of kittycad.models.unit_power.UnitPower.METRIC_HORSEPOWER

__annotations__ (kittycad.models.unit_power.UnitPower attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_power', '__doc__': 'The valid types of power units.', '__str__': <function UnitPower.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['BTU_PER_MINUTE', 'HORSEPOWER', 'KILOWATTS', 'METRIC_HORSEPOWER', 'MICROWATTS', 'MILLIWATTS', 'WATTS'], '_member_map_': {'BTU_PER_MINUTE': <UnitPower.BTU_PER_MINUTE: 'btu_per_minute'>, 'HORSEPOWER': <UnitPower.HORSEPOWER: 'horsepower'>, 'KILOWATTS': <UnitPower.KILOWATTS: 'kilowatts'>, 'METRIC_HORSEPOWER': <UnitPower.METRIC_HORSEPOWER: 'metric_horsepower'>, 'MICROWATTS': <UnitPower.MICROWATTS: 'microwatts'>, 'MILLIWATTS': <UnitPower.MILLIWATTS: 'milliwatts'>, 'WATTS': <UnitPower.WATTS: 'watts'>}, '_value2member_map_': {'btu_per_minute': <UnitPower.BTU_PER_MINUTE: 'btu_per_minute'>, 'horsepower': <UnitPower.HORSEPOWER: 'horsepower'>, 'kilowatts': <UnitPower.KILOWATTS: 'kilowatts'>, 'metric_horsepower': <UnitPower.METRIC_HORSEPOWER: 'metric_horsepower'>, 'microwatts': <UnitPower.MICROWATTS: 'microwatts'>, 'milliwatts': <UnitPower.MILLIWATTS: 'milliwatts'>, 'watts': <UnitPower.WATTS: 'watts'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitPower' objects>, '__weakref__': <attribute '__weakref__' of 'UnitPower' objects>, 'BTU_PER_MINUTE': <UnitPower.BTU_PER_MINUTE: 'btu_per_minute'>, 'HORSEPOWER': <UnitPower.HORSEPOWER: 'horsepower'>, 'KILOWATTS': <UnitPower.KILOWATTS: 'kilowatts'>, 'METRIC_HORSEPOWER': <UnitPower.METRIC_HORSEPOWER: 'metric_horsepower'>, 'MICROWATTS': <UnitPower.MICROWATTS: 'microwatts'>, 'MILLIWATTS': <UnitPower.MILLIWATTS: 'milliwatts'>, 'WATTS': <UnitPower.WATTS: 'watts'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_power.UnitPower method)

_generate_next_value_() (kittycad.models.unit_power.UnitPower method)

{'BTU_PER_MINUTE': UnitPower.BTU_PER_MINUTE, 'HORSEPOWER': UnitPower.HORSEPOWER, 'KILOWATTS': UnitPower.KILOWATTS, 'METRIC_HORSEPOWER': UnitPower.METRIC_HORSEPOWER, 'MICROWATTS': UnitPower.MICROWATTS, 'MILLIWATTS': UnitPower.MILLIWATTS, 'WATTS': UnitPower.WATTS}

['BTU_PER_MINUTE', 'HORSEPOWER', 'KILOWATTS', 'METRIC_HORSEPOWER', 'MICROWATTS', 'MILLIWATTS', 'WATTS']

_unhashable_values_ (kittycad.models.unit_power.UnitPower attribute)

_value2member_map_ (kittycad.models.unit_power.UnitPower attribute)

{'btu_per_minute': UnitPower.BTU_PER_MINUTE, 'horsepower': UnitPower.HORSEPOWER, 'kilowatts': UnitPower.KILOWATTS, 'metric_horsepower': UnitPower.METRIC_HORSEPOWER, 'microwatts': UnitPower.MICROWATTS, 'milliwatts': UnitPower.MILLIWATTS, 'watts': UnitPower.WATTS}

maketrans() (kittycad.models.unit_power.UnitPower static method)

:py:obj:`__init__ <kittycad.models.unit_power.UnitPower.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_power.UnitPower.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_power.UnitPower.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_power.UnitPower.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_power.UnitPower.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_power.UnitPower.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_power.UnitPower.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_power.UnitPower.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_power.UnitPower.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_power.UnitPower.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_power.UnitPower.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_power.UnitPower.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_power.UnitPower.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_power.UnitPower.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_power.UnitPower.isdigit>`\ \(\)

:py:obj:`isidentifier <kittycad.models.unit_power.UnitPower.isidentifier>`\ \(\)

:py:obj:`islower <kittycad.models.unit_power.UnitPower.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_power.UnitPower.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_power.UnitPower.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_power.UnitPower.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_power.UnitPower.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_power.UnitPower.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_power.UnitPower.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_power.UnitPower.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_power.UnitPower.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_power.UnitPower.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_power.UnitPower.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_power.UnitPower.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_power.UnitPower.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_power.UnitPower.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_power.UnitPower.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_power.UnitPower.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_power.UnitPower.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_power.UnitPower.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_power.UnitPower.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_power.UnitPower.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_power.UnitPower.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_power.UnitPower.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_power.UnitPower.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_power.UnitPower.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_power.UnitPower.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_power.UnitPower.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_power.UnitPower.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_power.UnitPower.zfill>`\ \(width\, \/\)

BTU_PER_MINUTE

//en.wikipedia.org/wiki/Horsepower>

HORSEPOWER

//en.wikipedia.org/wiki/Kilowatt>

KILOWATTS

//en.wikipedia.org/wiki/Horsepower#Metric_horsepower>

METRIC_HORSEPOWER

//en.wikipedia.org/wiki/Microwatt>

MICROWATTS

//en.wikipedia.org/wiki/Milliwatt>

MILLIWATTS

//en.wikipedia.org/wiki/Watt>

WATTS

UnitPowerConversion([completed_at, ...])

:py:obj:`UnitPowerConversion <kittycad.models.unit_power_conversion.UnitPowerConversion>`\ \(\[completed\_at\, ...\]\)

UnitPowerConversion (class in kittycad.models.unit_power_conversion)

UnitPowerConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__delitem__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__dict__ (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_power_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitPowerConversion.to_dict>, 'from_dict': <classmethod(<function UnitPowerConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitPowerConversion.__getitem__>, '__setitem__': <function UnitPowerConversion.__setitem__>, '__delitem__': <function UnitPowerConversion.__delitem__>, '__contains__': <function UnitPowerConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitPowerConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitPowerConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_power.UnitPower], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitPowerConversion.__repr__>, '__eq__': <function UnitPowerConversion.__eq__>, '__ne__': <function UnitPowerConversion.__ne__>, '__lt__': <function UnitPowerConversion.__lt__>, '__le__': <function UnitPowerConversion.__le__>, '__gt__': <function UnitPowerConversion.__gt__>, '__ge__': <function UnitPowerConversion.__ge__>, '__hash__': None, '__init__': <function UnitPowerConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__ge__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__getitem__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__gt__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__hash__ (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

__init__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

UnitPowerConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__lt__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__module__ (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

__ne__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__repr__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

__setitem__() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

created_at (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

error (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

from_dict() (kittycad.models.unit_power_conversion.UnitPowerConversion class method)

id (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

input (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

input_unit (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

output (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

started_at (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

status (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

to_dict() (kittycad.models.unit_power_conversion.UnitPowerConversion method)

updated_at (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

user_id (kittycad.models.unit_power_conversion.UnitPowerConversion attribute)

Method generated by attrs for class UnitPowerConversion.

rtype

TypeVar(SO, bound= UnitPowerConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_power_conversion.UnitPowerConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``SO``, bound= UnitPowerConversion)

UnitPressure(value[, names, module, ...])

The valid types of pressure units.

:py:obj:`UnitPressure <kittycad.models.unit_pressure.UnitPressure>`\ \(value\[\, names\, module\, ...\]\)

UnitPressure(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

ATMOSPHERES (kittycad.models.unit_pressure.UnitPressure attribute)

docstring of kittycad.models.unit_pressure.UnitPressure.ATMOSPHERES

HECTOPASCALS (kittycad.models.unit_pressure.UnitPressure attribute)

docstring of kittycad.models.unit_pressure.UnitPressure.HECTOPASCALS

KILOPASCALS (kittycad.models.unit_pressure.UnitPressure attribute)

docstring of kittycad.models.unit_pressure.UnitPressure.KILOPASCALS

MILLIBARS (kittycad.models.unit_pressure.UnitPressure attribute)

docstring of kittycad.models.unit_pressure.UnitPressure.MILLIBARS

__annotations__ (kittycad.models.unit_pressure.UnitPressure attribute)

__contains__() (kittycad.models.unit_pressure.UnitPressure method)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_pressure', '__doc__': 'The valid types of pressure units.', '__str__': <function UnitPressure.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['ATMOSPHERES', 'BARS', 'HECTOPASCALS', 'KILOPASCALS', 'MILLIBARS', 'PASCALS', 'PSI'], '_member_map_': {'ATMOSPHERES': <UnitPressure.ATMOSPHERES: 'atmospheres'>, 'BARS': <UnitPressure.BARS: 'bars'>, 'HECTOPASCALS': <UnitPressure.HECTOPASCALS: 'hectopascals'>, 'KILOPASCALS': <UnitPressure.KILOPASCALS: 'kilopascals'>, 'MILLIBARS': <UnitPressure.MILLIBARS: 'millibars'>, 'PASCALS': <UnitPressure.PASCALS: 'pascals'>, 'PSI': <UnitPressure.PSI: 'psi'>}, '_value2member_map_': {'atmospheres': <UnitPressure.ATMOSPHERES: 'atmospheres'>, 'bars': <UnitPressure.BARS: 'bars'>, 'hectopascals': <UnitPressure.HECTOPASCALS: 'hectopascals'>, 'kilopascals': <UnitPressure.KILOPASCALS: 'kilopascals'>, 'millibars': <UnitPressure.MILLIBARS: 'millibars'>, 'pascals': <UnitPressure.PASCALS: 'pascals'>, 'psi': <UnitPressure.PSI: 'psi'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitPressure' objects>, '__weakref__': <attribute '__weakref__' of 'UnitPressure' objects>, 'ATMOSPHERES': <UnitPressure.ATMOSPHERES: 'atmospheres'>, 'BARS': <UnitPressure.BARS: 'bars'>, 'HECTOPASCALS': <UnitPressure.HECTOPASCALS: 'hectopascals'>, 'KILOPASCALS': <UnitPressure.KILOPASCALS: 'kilopascals'>, 'MILLIBARS': <UnitPressure.MILLIBARS: 'millibars'>, 'PASCALS': <UnitPressure.PASCALS: 'pascals'>, 'PSI': <UnitPressure.PSI: 'psi'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__format__() (kittycad.models.unit_pressure.UnitPressure method)

__getattribute__() (kittycad.models.unit_pressure.UnitPressure method)

__getitem__() (kittycad.models.unit_pressure.UnitPressure method)

__getnewargs__() (kittycad.models.unit_pressure.UnitPressure method)

__module__ (kittycad.models.unit_pressure.UnitPressure attribute)

__reduce_ex__() (kittycad.models.unit_pressure.UnitPressure method)

__sizeof__() (kittycad.models.unit_pressure.UnitPressure method)

_generate_next_value_() (kittycad.models.unit_pressure.UnitPressure method)

_member_map_ (kittycad.models.unit_pressure.UnitPressure attribute)

{'ATMOSPHERES': UnitPressure.ATMOSPHERES, 'BARS': UnitPressure.BARS, 'HECTOPASCALS': UnitPressure.HECTOPASCALS, 'KILOPASCALS': UnitPressure.KILOPASCALS, 'MILLIBARS': UnitPressure.MILLIBARS, 'PASCALS': UnitPressure.PASCALS, 'PSI': UnitPressure.PSI}

_member_names_ (kittycad.models.unit_pressure.UnitPressure attribute)

['ATMOSPHERES', 'BARS', 'HECTOPASCALS', 'KILOPASCALS', 'MILLIBARS', 'PASCALS', 'PSI']

_member_type_ (kittycad.models.unit_pressure.UnitPressure attribute)

_new_member_() (kittycad.models.unit_pressure.UnitPressure method)

_unhashable_values_ (kittycad.models.unit_pressure.UnitPressure attribute)

_use_args_ (kittycad.models.unit_pressure.UnitPressure attribute)

_value2member_map_ (kittycad.models.unit_pressure.UnitPressure attribute)

{'atmospheres': UnitPressure.ATMOSPHERES, 'bars': UnitPressure.BARS, 'hectopascals': UnitPressure.HECTOPASCALS, 'kilopascals': UnitPressure.KILOPASCALS, 'millibars': UnitPressure.MILLIBARS, 'pascals': UnitPressure.PASCALS, 'psi': UnitPressure.PSI}

_value_repr_() (kittycad.models.unit_pressure.UnitPressure method)

capitalize() (kittycad.models.unit_pressure.UnitPressure method)

expandtabs() (kittycad.models.unit_pressure.UnitPressure method)

format_map() (kittycad.models.unit_pressure.UnitPressure method)

isidentifier() (kittycad.models.unit_pressure.UnitPressure method)

isprintable() (kittycad.models.unit_pressure.UnitPressure method)

maketrans() (kittycad.models.unit_pressure.UnitPressure static method)

removeprefix() (kittycad.models.unit_pressure.UnitPressure method)

removesuffix() (kittycad.models.unit_pressure.UnitPressure method)

rpartition() (kittycad.models.unit_pressure.UnitPressure method)

splitlines() (kittycad.models.unit_pressure.UnitPressure method)

startswith() (kittycad.models.unit_pressure.UnitPressure method)

:py:obj:`__init__ <kittycad.models.unit_pressure.UnitPressure.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`casefold <kittycad.models.unit_pressure.UnitPressure.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_pressure.UnitPressure.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_pressure.UnitPressure.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_pressure.UnitPressure.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_pressure.UnitPressure.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_pressure.UnitPressure.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_pressure.UnitPressure.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_pressure.UnitPressure.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_pressure.UnitPressure.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_pressure.UnitPressure.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_pressure.UnitPressure.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_pressure.UnitPressure.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_pressure.UnitPressure.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_pressure.UnitPressure.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_pressure.UnitPressure.isnumeric>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_pressure.UnitPressure.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_pressure.UnitPressure.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_pressure.UnitPressure.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_pressure.UnitPressure.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_pressure.UnitPressure.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_pressure.UnitPressure.lower>`\ \(\)

:py:obj:`partition <kittycad.models.unit_pressure.UnitPressure.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_pressure.UnitPressure.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_pressure.UnitPressure.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_pressure.UnitPressure.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_pressure.UnitPressure.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_pressure.UnitPressure.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_pressure.UnitPressure.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_pressure.UnitPressure.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_pressure.UnitPressure.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.unit_pressure.UnitPressure.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_pressure.UnitPressure.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`swapcase <kittycad.models.unit_pressure.UnitPressure.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_pressure.UnitPressure.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_pressure.UnitPressure.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_pressure.UnitPressure.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_pressure.UnitPressure.zfill>`\ \(width\, \/\)

ATMOSPHERES

//en.wikipedia.org/wiki/Bar_(unit)>

BARS

//en.wikipedia.org/wiki/Hectopascal>

HECTOPASCALS

//en.wikipedia.org/wiki/Kilopascal>

KILOPASCALS

MILLIBARS

//en.wikipedia.org/wiki/Pascal_(unit)>

PASCALS

//en.wikipedia.org/wiki/Pound_per_square_inch>

PSI

UnitPressureConversion([completed_at, ...])

UnitPressureConversion (class in kittycad.models.unit_pressure_conversion)

UnitPressureConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.unit_pressure_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitPressureConversion.to_dict>, 'from_dict': <classmethod(<function UnitPressureConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitPressureConversion.__getitem__>, '__setitem__': <function UnitPressureConversion.__setitem__>, '__delitem__': <function UnitPressureConversion.__delitem__>, '__contains__': <function UnitPressureConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitPressureConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitPressureConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_pressure.UnitPressure], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitPressureConversion.__repr__>, '__eq__': <function UnitPressureConversion.__eq__>, '__ne__': <function UnitPressureConversion.__ne__>, '__lt__': <function UnitPressureConversion.__lt__>, '__le__': <function UnitPressureConversion.__le__>, '__gt__': <function UnitPressureConversion.__gt__>, '__ge__': <function UnitPressureConversion.__ge__>, '__hash__': None, '__init__': <function UnitPressureConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

UnitPressureConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

from_dict() (kittycad.models.unit_pressure_conversion.UnitPressureConversion class method)

id (kittycad.models.unit_pressure_conversion.UnitPressureConversion attribute)

Method generated by attrs for class UnitPressureConversion.

rtype

TypeVar(ZS, bound= UnitPressureConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_pressure_conversion.UnitPressureConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``ZS``, bound= UnitPressureConversion)

UnitTemperature(value[, names, module, ...])

The valid types of temperature units.

:py:obj:`UnitTemperature <kittycad.models.unit_temperature.UnitTemperature>`\ \(value\[\, names\, module\, ...\]\)

UnitTemperature(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

CELSIUS (kittycad.models.unit_temperature.UnitTemperature attribute)

docstring of kittycad.models.unit_temperature.UnitTemperature.CELSIUS

FAHRENHEIT (kittycad.models.unit_temperature.UnitTemperature attribute)

docstring of kittycad.models.unit_temperature.UnitTemperature.FAHRENHEIT

KELVIN (kittycad.models.unit_temperature.UnitTemperature attribute)

docstring of kittycad.models.unit_temperature.UnitTemperature.KELVIN

RANKINE (kittycad.models.unit_temperature.UnitTemperature attribute)

__add__() (kittycad.models.unit_temperature.UnitTemperature method)

__annotations__ (kittycad.models.unit_temperature.UnitTemperature attribute)

__contains__() (kittycad.models.unit_temperature.UnitTemperature method)

__dict__ (kittycad.models.unit_temperature.UnitTemperature attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_temperature', '__doc__': 'The valid types of temperature units.', '__str__': <function UnitTemperature.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CELSIUS', 'FAHRENHEIT', 'KELVIN', 'RANKINE'], '_member_map_': {'CELSIUS': <UnitTemperature.CELSIUS: 'celsius'>, 'FAHRENHEIT': <UnitTemperature.FAHRENHEIT: 'fahrenheit'>, 'KELVIN': <UnitTemperature.KELVIN: 'kelvin'>, 'RANKINE': <UnitTemperature.RANKINE: 'rankine'>}, '_value2member_map_': {'celsius': <UnitTemperature.CELSIUS: 'celsius'>, 'fahrenheit': <UnitTemperature.FAHRENHEIT: 'fahrenheit'>, 'kelvin': <UnitTemperature.KELVIN: 'kelvin'>, 'rankine': <UnitTemperature.RANKINE: 'rankine'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitTemperature' objects>, '__weakref__': <attribute '__weakref__' of 'UnitTemperature' objects>, 'CELSIUS': <UnitTemperature.CELSIUS: 'celsius'>, 'FAHRENHEIT': <UnitTemperature.FAHRENHEIT: 'fahrenheit'>, 'KELVIN': <UnitTemperature.KELVIN: 'kelvin'>, 'RANKINE': <UnitTemperature.RANKINE: 'rankine'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__dir__() (kittycad.models.unit_temperature.UnitTemperature method)

__eq__() (kittycad.models.unit_temperature.UnitTemperature method)

__format__() (kittycad.models.unit_temperature.UnitTemperature method)

__ge__() (kittycad.models.unit_temperature.UnitTemperature method)

__getattribute__() (kittycad.models.unit_temperature.UnitTemperature method)

__getitem__() (kittycad.models.unit_temperature.UnitTemperature method)

__getnewargs__() (kittycad.models.unit_temperature.UnitTemperature method)

__gt__() (kittycad.models.unit_temperature.UnitTemperature method)

__hash__() (kittycad.models.unit_temperature.UnitTemperature method)

__init__() (kittycad.models.unit_temperature.UnitTemperature method)

__iter__() (kittycad.models.unit_temperature.UnitTemperature method)

__le__() (kittycad.models.unit_temperature.UnitTemperature method)

__len__() (kittycad.models.unit_temperature.UnitTemperature method)

__lt__() (kittycad.models.unit_temperature.UnitTemperature method)

__mod__() (kittycad.models.unit_temperature.UnitTemperature method)

__module__ (kittycad.models.unit_temperature.UnitTemperature attribute)

__mul__() (kittycad.models.unit_temperature.UnitTemperature method)

__ne__() (kittycad.models.unit_temperature.UnitTemperature method)

__new__() (kittycad.models.unit_temperature.UnitTemperature method)

__reduce_ex__() (kittycad.models.unit_temperature.UnitTemperature method)

__repr__() (kittycad.models.unit_temperature.UnitTemperature method)

__rmod__() (kittycad.models.unit_temperature.UnitTemperature method)

__rmul__() (kittycad.models.unit_temperature.UnitTemperature method)

__sizeof__() (kittycad.models.unit_temperature.UnitTemperature method)

__str__() (kittycad.models.unit_temperature.UnitTemperature method)

UnitTemperature._generate_next_value_(start, count, last_values)

_member_map_ (kittycad.models.unit_temperature.UnitTemperature attribute)

{'CELSIUS': UnitTemperature.CELSIUS, 'FAHRENHEIT': UnitTemperature.FAHRENHEIT, 'KELVIN': UnitTemperature.KELVIN, 'RANKINE': UnitTemperature.RANKINE}

_member_names_ (kittycad.models.unit_temperature.UnitTemperature attribute)

_member_type_ (kittycad.models.unit_temperature.UnitTemperature attribute)

_new_member_() (kittycad.models.unit_temperature.UnitTemperature method)

_unhashable_values_ (kittycad.models.unit_temperature.UnitTemperature attribute)

_use_args_ (kittycad.models.unit_temperature.UnitTemperature attribute)

_value2member_map_ (kittycad.models.unit_temperature.UnitTemperature attribute)

{'celsius': UnitTemperature.CELSIUS, 'fahrenheit': UnitTemperature.FAHRENHEIT, 'kelvin': UnitTemperature.KELVIN, 'rankine': UnitTemperature.RANKINE}

_value_repr_() (kittycad.models.unit_temperature.UnitTemperature method)

capitalize() (kittycad.models.unit_temperature.UnitTemperature method)

casefold() (kittycad.models.unit_temperature.UnitTemperature method)

center() (kittycad.models.unit_temperature.UnitTemperature method)

count() (kittycad.models.unit_temperature.UnitTemperature method)

encode() (kittycad.models.unit_temperature.UnitTemperature method)

endswith() (kittycad.models.unit_temperature.UnitTemperature method)

expandtabs() (kittycad.models.unit_temperature.UnitTemperature method)

find() (kittycad.models.unit_temperature.UnitTemperature method)

format() (kittycad.models.unit_temperature.UnitTemperature method)

format_map() (kittycad.models.unit_temperature.UnitTemperature method)

index() (kittycad.models.unit_temperature.UnitTemperature method)

isalnum() (kittycad.models.unit_temperature.UnitTemperature method)

isalpha() (kittycad.models.unit_temperature.UnitTemperature method)

isascii() (kittycad.models.unit_temperature.UnitTemperature method)

isdecimal() (kittycad.models.unit_temperature.UnitTemperature method)

isdigit() (kittycad.models.unit_temperature.UnitTemperature method)

isidentifier() (kittycad.models.unit_temperature.UnitTemperature method)

islower() (kittycad.models.unit_temperature.UnitTemperature method)

isnumeric() (kittycad.models.unit_temperature.UnitTemperature method)

isprintable() (kittycad.models.unit_temperature.UnitTemperature method)

isspace() (kittycad.models.unit_temperature.UnitTemperature method)

istitle() (kittycad.models.unit_temperature.UnitTemperature method)

isupper() (kittycad.models.unit_temperature.UnitTemperature method)

join() (kittycad.models.unit_temperature.UnitTemperature method)

ljust() (kittycad.models.unit_temperature.UnitTemperature method)

lower() (kittycad.models.unit_temperature.UnitTemperature method)

lstrip() (kittycad.models.unit_temperature.UnitTemperature method)

maketrans() (kittycad.models.unit_temperature.UnitTemperature static method)

partition() (kittycad.models.unit_temperature.UnitTemperature method)

removeprefix() (kittycad.models.unit_temperature.UnitTemperature method)

removesuffix() (kittycad.models.unit_temperature.UnitTemperature method)

replace() (kittycad.models.unit_temperature.UnitTemperature method)

rfind() (kittycad.models.unit_temperature.UnitTemperature method)

rindex() (kittycad.models.unit_temperature.UnitTemperature method)

rjust() (kittycad.models.unit_temperature.UnitTemperature method)

rpartition() (kittycad.models.unit_temperature.UnitTemperature method)

rsplit() (kittycad.models.unit_temperature.UnitTemperature method)

rstrip() (kittycad.models.unit_temperature.UnitTemperature method)

split() (kittycad.models.unit_temperature.UnitTemperature method)

splitlines() (kittycad.models.unit_temperature.UnitTemperature method)

startswith() (kittycad.models.unit_temperature.UnitTemperature method)

strip() (kittycad.models.unit_temperature.UnitTemperature method)

swapcase() (kittycad.models.unit_temperature.UnitTemperature method)

title() (kittycad.models.unit_temperature.UnitTemperature method)

translate() (kittycad.models.unit_temperature.UnitTemperature method)

upper() (kittycad.models.unit_temperature.UnitTemperature method)

zfill() (kittycad.models.unit_temperature.UnitTemperature method)

:py:obj:`__init__ <kittycad.models.unit_temperature.UnitTemperature.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`center <kittycad.models.unit_temperature.UnitTemperature.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_temperature.UnitTemperature.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_temperature.UnitTemperature.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_temperature.UnitTemperature.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_temperature.UnitTemperature.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_temperature.UnitTemperature.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_temperature.UnitTemperature.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`join <kittycad.models.unit_temperature.UnitTemperature.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_temperature.UnitTemperature.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_temperature.UnitTemperature.lower>`\ \(\)

:py:obj:`partition <kittycad.models.unit_temperature.UnitTemperature.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_temperature.UnitTemperature.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_temperature.UnitTemperature.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_temperature.UnitTemperature.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_temperature.UnitTemperature.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_temperature.UnitTemperature.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_temperature.UnitTemperature.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_temperature.UnitTemperature.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_temperature.UnitTemperature.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`split <kittycad.models.unit_temperature.UnitTemperature.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_temperature.UnitTemperature.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`title <kittycad.models.unit_temperature.UnitTemperature.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_temperature.UnitTemperature.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_temperature.UnitTemperature.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_temperature.UnitTemperature.zfill>`\ \(width\, \/\)

CELSIUS

//en.wikipedia.org/wiki/Fahrenheit>

FAHRENHEIT

//en.wikipedia.org/wiki/Kelvin>

KELVIN

//en.wikipedia.org/wiki/Rankine_scale>

RANKINE

UnitTemperatureConversion([completed_at, ...])

UnitTemperatureConversion (class in kittycad.models.unit_temperature_conversion)

UnitTemperatureConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.unit_temperature_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitTemperatureConversion.to_dict>, 'from_dict': <classmethod(<function UnitTemperatureConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitTemperatureConversion.__getitem__>, '__setitem__': <function UnitTemperatureConversion.__setitem__>, '__delitem__': <function UnitTemperatureConversion.__delitem__>, '__contains__': <function UnitTemperatureConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitTemperatureConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitTemperatureConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_temperature.UnitTemperature], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitTemperatureConversion.__repr__>, '__eq__': <function UnitTemperatureConversion.__eq__>, '__ne__': <function UnitTemperatureConversion.__ne__>, '__lt__': <function UnitTemperatureConversion.__lt__>, '__le__': <function UnitTemperatureConversion.__le__>, '__gt__': <function UnitTemperatureConversion.__gt__>, '__ge__': <function UnitTemperatureConversion.__ge__>, '__hash__': None, '__init__': <function UnitTemperatureConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

UnitTemperatureConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

from_dict() (kittycad.models.unit_temperature_conversion.UnitTemperatureConversion class method)

Method generated by attrs for class UnitTemperatureConversion.

rtype

TypeVar(AM, bound= UnitTemperatureConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_temperature_conversion.UnitTemperatureConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``AM``, bound= UnitTemperatureConversion)

UnitTorque(value[, names, module, qualname, ...])

The valid types of torque units.

:py:obj:`UnitTorque <kittycad.models.unit_torque.UnitTorque>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitTorque(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

NEWTON_METRES (kittycad.models.unit_torque.UnitTorque attribute)

docstring of kittycad.models.unit_torque.UnitTorque.NEWTON_METRES

__annotations__ (kittycad.models.unit_torque.UnitTorque attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_torque', '__doc__': 'The valid types of torque units.', '__str__': <function UnitTorque.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['NEWTON_METRES', 'POUND_FOOT'], '_member_map_': {'NEWTON_METRES': <UnitTorque.NEWTON_METRES: 'newton_metres'>, 'POUND_FOOT': <UnitTorque.POUND_FOOT: 'pound_foot'>}, '_value2member_map_': {'newton_metres': <UnitTorque.NEWTON_METRES: 'newton_metres'>, 'pound_foot': <UnitTorque.POUND_FOOT: 'pound_foot'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitTorque' objects>, '__weakref__': <attribute '__weakref__' of 'UnitTorque' objects>, 'NEWTON_METRES': <UnitTorque.NEWTON_METRES: 'newton_metres'>, 'POUND_FOOT': <UnitTorque.POUND_FOOT: 'pound_foot'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_torque.UnitTorque method)

__getnewargs__() (kittycad.models.unit_torque.UnitTorque method)

_generate_next_value_() (kittycad.models.unit_torque.UnitTorque method)

{'NEWTON_METRES': UnitTorque.NEWTON_METRES, 'POUND_FOOT': UnitTorque.POUND_FOOT}

_member_names_ (kittycad.models.unit_torque.UnitTorque attribute)

_member_type_ (kittycad.models.unit_torque.UnitTorque attribute)

_unhashable_values_ (kittycad.models.unit_torque.UnitTorque attribute)

_value2member_map_ (kittycad.models.unit_torque.UnitTorque attribute)

{'newton_metres': UnitTorque.NEWTON_METRES, 'pound_foot': UnitTorque.POUND_FOOT}

maketrans() (kittycad.models.unit_torque.UnitTorque static method)

:py:obj:`__init__ <kittycad.models.unit_torque.UnitTorque.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_torque.UnitTorque.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_torque.UnitTorque.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_torque.UnitTorque.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_torque.UnitTorque.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_torque.UnitTorque.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_torque.UnitTorque.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_torque.UnitTorque.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_torque.UnitTorque.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_torque.UnitTorque.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_torque.UnitTorque.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_torque.UnitTorque.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_torque.UnitTorque.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_torque.UnitTorque.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_torque.UnitTorque.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_torque.UnitTorque.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_torque.UnitTorque.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_torque.UnitTorque.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_torque.UnitTorque.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_torque.UnitTorque.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_torque.UnitTorque.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_torque.UnitTorque.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_torque.UnitTorque.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_torque.UnitTorque.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_torque.UnitTorque.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_torque.UnitTorque.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_torque.UnitTorque.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_torque.UnitTorque.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_torque.UnitTorque.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_torque.UnitTorque.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_torque.UnitTorque.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_torque.UnitTorque.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_torque.UnitTorque.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_torque.UnitTorque.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_torque.UnitTorque.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_torque.UnitTorque.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_torque.UnitTorque.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_torque.UnitTorque.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_torque.UnitTorque.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_torque.UnitTorque.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_torque.UnitTorque.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_torque.UnitTorque.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_torque.UnitTorque.zfill>`\ \(width\, \/\)

NEWTON_METRES

//en.wikipedia.org/wiki/Pound-foot_(torque)>

POUND_FOOT

UnitTorqueConversion([completed_at, ...])

UnitTorqueConversion (class in kittycad.models.unit_torque_conversion)

UnitTorqueConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_torque_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitTorqueConversion.to_dict>, 'from_dict': <classmethod(<function UnitTorqueConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitTorqueConversion.__getitem__>, '__setitem__': <function UnitTorqueConversion.__setitem__>, '__delitem__': <function UnitTorqueConversion.__delitem__>, '__contains__': <function UnitTorqueConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitTorqueConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitTorqueConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_torque.UnitTorque], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitTorqueConversion.__repr__>, '__eq__': <function UnitTorqueConversion.__eq__>, '__ne__': <function UnitTorqueConversion.__ne__>, '__lt__': <function UnitTorqueConversion.__lt__>, '__le__': <function UnitTorqueConversion.__le__>, '__gt__': <function UnitTorqueConversion.__gt__>, '__ge__': <function UnitTorqueConversion.__ge__>, '__hash__': None, '__init__': <function UnitTorqueConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__ge__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__gt__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__hash__ (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

__init__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

UnitTorqueConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__lt__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__ne__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

__repr__() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

error (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

from_dict() (kittycad.models.unit_torque_conversion.UnitTorqueConversion class method)

id (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

input (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

output (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

status (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

to_dict() (kittycad.models.unit_torque_conversion.UnitTorqueConversion method)

user_id (kittycad.models.unit_torque_conversion.UnitTorqueConversion attribute)

Method generated by attrs for class UnitTorqueConversion.

rtype

TypeVar(GK, bound= UnitTorqueConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_torque_conversion.UnitTorqueConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``GK``, bound= UnitTorqueConversion)

UnitVolume(value[, names, module, qualname, ...])

The valid types of volume units.

:py:obj:`UnitVolume <kittycad.models.unit_volume.UnitVolume>`\ \(value\[\, names\, module\, qualname\, ...\]\)

UnitVolume(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

__annotations__ (kittycad.models.unit_volume.UnitVolume attribute)

mappingproxy({'_generate_next_value_': <function Enum._generate_next_value_>, '__module__': 'kittycad.models.unit_volume', '__doc__': 'The valid types of volume units.', '__str__': <function UnitVolume.__str__>, '_new_member_': <built-in method __new__ of type object>, '_use_args_': True, '_member_names_': ['CM3', 'FT3', 'IN3', 'M3', 'YD3', 'USFLOZ', 'USGAL', 'L', 'ML'], '_member_map_': {'CM3': <UnitVolume.CM3: 'cm3'>, 'FT3': <UnitVolume.FT3: 'ft3'>, 'IN3': <UnitVolume.IN3: 'in3'>, 'M3': <UnitVolume.M3: 'm3'>, 'YD3': <UnitVolume.YD3: 'yd3'>, 'USFLOZ': <UnitVolume.USFLOZ: 'usfloz'>, 'USGAL': <UnitVolume.USGAL: 'usgal'>, 'L': <UnitVolume.L: 'l'>, 'ML': <UnitVolume.ML: 'ml'>}, '_value2member_map_': {'cm3': <UnitVolume.CM3: 'cm3'>, 'ft3': <UnitVolume.FT3: 'ft3'>, 'in3': <UnitVolume.IN3: 'in3'>, 'm3': <UnitVolume.M3: 'm3'>, 'yd3': <UnitVolume.YD3: 'yd3'>, 'usfloz': <UnitVolume.USFLOZ: 'usfloz'>, 'usgal': <UnitVolume.USGAL: 'usgal'>, 'l': <UnitVolume.L: 'l'>, 'ml': <UnitVolume.ML: 'ml'>}, '_unhashable_values_': [], '_member_type_': <class 'str'>, '_value_repr_': <slot wrapper '__repr__' of 'str' objects>, '__dict__': <attribute '__dict__' of 'UnitVolume' objects>, '__weakref__': <attribute '__weakref__' of 'UnitVolume' objects>, 'CM3': <UnitVolume.CM3: 'cm3'>, 'FT3': <UnitVolume.FT3: 'ft3'>, 'IN3': <UnitVolume.IN3: 'in3'>, 'M3': <UnitVolume.M3: 'm3'>, 'YD3': <UnitVolume.YD3: 'yd3'>, 'USFLOZ': <UnitVolume.USFLOZ: 'usfloz'>, 'USGAL': <UnitVolume.USGAL: 'usgal'>, 'L': <UnitVolume.L: 'l'>, 'ML': <UnitVolume.ML: 'ml'>, '__repr__': <function Enum.__repr__>, '__format__': <function Enum.__format__>, '__new__': <function Enum.__new__>, '__annotations__': {}})

__getattribute__() (kittycad.models.unit_volume.UnitVolume method)

__getnewargs__() (kittycad.models.unit_volume.UnitVolume method)

_generate_next_value_() (kittycad.models.unit_volume.UnitVolume method)

{'CM3': UnitVolume.CM3, 'FT3': UnitVolume.FT3, 'IN3': UnitVolume.IN3, 'L': UnitVolume.L, 'M3': UnitVolume.M3, 'ML': UnitVolume.ML, 'USFLOZ': UnitVolume.USFLOZ, 'USGAL': UnitVolume.USGAL, 'YD3': UnitVolume.YD3}

_member_names_ (kittycad.models.unit_volume.UnitVolume attribute)

['CM3', 'FT3', 'IN3', 'M3', 'YD3', 'USFLOZ', 'USGAL', 'L', 'ML']

_member_type_ (kittycad.models.unit_volume.UnitVolume attribute)

_unhashable_values_ (kittycad.models.unit_volume.UnitVolume attribute)

_value2member_map_ (kittycad.models.unit_volume.UnitVolume attribute)

{'cm3': UnitVolume.CM3, 'ft3': UnitVolume.FT3, 'in3': UnitVolume.IN3, 'l': UnitVolume.L, 'm3': UnitVolume.M3, 'ml': UnitVolume.ML, 'usfloz': UnitVolume.USFLOZ, 'usgal': UnitVolume.USGAL, 'yd3': UnitVolume.YD3}

maketrans() (kittycad.models.unit_volume.UnitVolume static method)

:py:obj:`__init__ <kittycad.models.unit_volume.UnitVolume.__init__>`\ \(\*args\, \*\*kwds\)

:py:obj:`capitalize <kittycad.models.unit_volume.UnitVolume.capitalize>`\ \(\)

:py:obj:`casefold <kittycad.models.unit_volume.UnitVolume.casefold>`\ \(\)

:py:obj:`center <kittycad.models.unit_volume.UnitVolume.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.unit_volume.UnitVolume.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.unit_volume.UnitVolume.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.unit_volume.UnitVolume.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`find <kittycad.models.unit_volume.UnitVolume.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.unit_volume.UnitVolume.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`index <kittycad.models.unit_volume.UnitVolume.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isalnum <kittycad.models.unit_volume.UnitVolume.isalnum>`\ \(\)

:py:obj:`isalpha <kittycad.models.unit_volume.UnitVolume.isalpha>`\ \(\)

:py:obj:`isascii <kittycad.models.unit_volume.UnitVolume.isascii>`\ \(\)

:py:obj:`isdecimal <kittycad.models.unit_volume.UnitVolume.isdecimal>`\ \(\)

:py:obj:`isdigit <kittycad.models.unit_volume.UnitVolume.isdigit>`\ \(\)

:py:obj:`islower <kittycad.models.unit_volume.UnitVolume.islower>`\ \(\)

:py:obj:`isnumeric <kittycad.models.unit_volume.UnitVolume.isnumeric>`\ \(\)

:py:obj:`isprintable <kittycad.models.unit_volume.UnitVolume.isprintable>`\ \(\)

:py:obj:`isspace <kittycad.models.unit_volume.UnitVolume.isspace>`\ \(\)

:py:obj:`istitle <kittycad.models.unit_volume.UnitVolume.istitle>`\ \(\)

:py:obj:`isupper <kittycad.models.unit_volume.UnitVolume.isupper>`\ \(\)

:py:obj:`join <kittycad.models.unit_volume.UnitVolume.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.unit_volume.UnitVolume.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lower <kittycad.models.unit_volume.UnitVolume.lower>`\ \(\)

:py:obj:`lstrip <kittycad.models.unit_volume.UnitVolume.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.unit_volume.UnitVolume.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.unit_volume.UnitVolume.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.unit_volume.UnitVolume.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.unit_volume.UnitVolume.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.unit_volume.UnitVolume.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.unit_volume.UnitVolume.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.unit_volume.UnitVolume.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.unit_volume.UnitVolume.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.unit_volume.UnitVolume.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.unit_volume.UnitVolume.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.unit_volume.UnitVolume.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`startswith <kittycad.models.unit_volume.UnitVolume.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.unit_volume.UnitVolume.strip>`\ \(\[chars\]\)

:py:obj:`swapcase <kittycad.models.unit_volume.UnitVolume.swapcase>`\ \(\)

:py:obj:`title <kittycad.models.unit_volume.UnitVolume.title>`\ \(\)

:py:obj:`translate <kittycad.models.unit_volume.UnitVolume.translate>`\ \(table\, \/\)

:py:obj:`upper <kittycad.models.unit_volume.UnitVolume.upper>`\ \(\)

:py:obj:`zfill <kittycad.models.unit_volume.UnitVolume.zfill>`\ \(width\, \/\)

CM3

//en.wikipedia.org/wiki/Cubic_foot>

FT3

//en.wikipedia.org/wiki/Cubic_inch>

IN3

//en.wikipedia.org/wiki/Cubic_metre>

M3

//en.wikipedia.org/wiki/Cubic_yard>

YD3

//en.wikipedia.org/wiki/Fluid_ounce>

USFLOZ

//en.wikipedia.org/wiki/Gallon>

USGAL

//en.wikipedia.org/wiki/Litre>

L

ML

UnitVolumeConversion([completed_at, ...])

UnitVolumeConversion (class in kittycad.models.unit_volume_conversion)

UnitVolumeConversion(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str]}

(Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__dict__ (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

mappingproxy({'__module__': 'kittycad.models.unit_volume_conversion', '__annotations__': {'completed_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'error': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'input': typing.Union[kittycad.types.Unset, float], 'input_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'output': typing.Union[kittycad.types.Unset, float], 'output_unit': typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], 'started_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'status': typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'user_id': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'Result of converting between units.', 'to_dict': <function UnitVolumeConversion.to_dict>, 'from_dict': <classmethod(<function UnitVolumeConversion.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UnitVolumeConversion.__getitem__>, '__setitem__': <function UnitVolumeConversion.__setitem__>, '__delitem__': <function UnitVolumeConversion.__delitem__>, '__contains__': <function UnitVolumeConversion.__contains__>, '__dict__': <attribute '__dict__' of 'UnitVolumeConversion' objects>, '__weakref__': <attribute '__weakref__' of 'UnitVolumeConversion' objects>, '__attrs_attrs__': (Attribute(name='completed_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='completed_at'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='error', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='error'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='input', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input'), Attribute(name='input_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='input_unit'), Attribute(name='output', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, float], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output'), Attribute(name='output_unit', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.unit_volume.UnitVolume], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='output_unit'), Attribute(name='started_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='started_at'), Attribute(name='status', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, kittycad.models.api_call_status.ApiCallStatus], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='user_id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='user_id'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UnitVolumeConversion.__repr__>, '__eq__': <function UnitVolumeConversion.__eq__>, '__ne__': <function UnitVolumeConversion.__ne__>, '__lt__': <function UnitVolumeConversion.__lt__>, '__le__': <function UnitVolumeConversion.__le__>, '__gt__': <function UnitVolumeConversion.__gt__>, '__ge__': <function UnitVolumeConversion.__ge__>, '__hash__': None, '__init__': <function UnitVolumeConversion.__init__>, '__match_args__': ('completed_at', 'created_at', 'error', 'id', 'input', 'input_unit', 'output', 'output_unit', 'started_at', 'status', 'updated_at', 'user_id')})

__eq__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__ge__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__gt__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__hash__ (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

__init__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

UnitVolumeConversion.__init__(completed_at=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, error=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, input=<kittycad.types.Unset object>, input_unit=<kittycad.types.Unset object>, output=<kittycad.types.Unset object>, output_unit=<kittycad.types.Unset object>, started_at=<kittycad.types.Unset object>, status=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>, user_id=<kittycad.types.Unset object>)

__le__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__lt__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__ne__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

__repr__() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

error (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

from_dict() (kittycad.models.unit_volume_conversion.UnitVolumeConversion class method)

id (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

input (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

output (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

status (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

to_dict() (kittycad.models.unit_volume_conversion.UnitVolumeConversion method)

user_id (kittycad.models.unit_volume_conversion.UnitVolumeConversion attribute)

Method generated by attrs for class UnitVolumeConversion.

rtype

TypeVar(SG, bound= UnitVolumeConversion)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.unit_volume_conversion.UnitVolumeConversion.__init__>`\ \(\[completed\_at\, created\_at\, error\, ...\]\)

:py:class:`~typing.TypeVar`\(``SG``, bound= UnitVolumeConversion)

UpdateUser([company, discord, first_name, ...])

The user-modifiable parts of a User.

:py:obj:`UpdateUser <kittycad.models.update_user.UpdateUser>`\ \(\[company\, discord\, first\_name\, ...\]\)

UpdateUser(company=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

(company=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.update_user.UpdateUser attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'company': typing.Union[kittycad.types.Unset, str], 'discord': typing.Union[kittycad.types.Unset, str], 'first_name': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.update_user.UpdateUser attribute)

(Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.update_user', '__annotations__': {'company': typing.Union[kittycad.types.Unset, str], 'discord': typing.Union[kittycad.types.Unset, str], 'first_name': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'The user-modifiable parts of a User.', 'to_dict': <function UpdateUser.to_dict>, 'from_dict': <classmethod(<function UpdateUser.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UpdateUser.__getitem__>, '__setitem__': <function UpdateUser.__setitem__>, '__delitem__': <function UpdateUser.__delitem__>, '__contains__': <function UpdateUser.__contains__>, '__dict__': <attribute '__dict__' of 'UpdateUser' objects>, '__weakref__': <attribute '__weakref__' of 'UpdateUser' objects>, '__attrs_attrs__': (Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UpdateUser.__repr__>, '__eq__': <function UpdateUser.__eq__>, '__ne__': <function UpdateUser.__ne__>, '__lt__': <function UpdateUser.__lt__>, '__le__': <function UpdateUser.__le__>, '__gt__': <function UpdateUser.__gt__>, '__ge__': <function UpdateUser.__ge__>, '__hash__': None, '__init__': <function UpdateUser.__init__>, '__match_args__': ('company', 'discord', 'first_name', 'github', 'last_name', 'phone')})

UpdateUser.__init__(company=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>)

__match_args__ (kittycad.models.update_user.UpdateUser attribute)

('company', 'discord', 'first_name', 'github', 'last_name', 'phone')

additional_keys (kittycad.models.update_user.UpdateUser property)

additional_properties (kittycad.models.update_user.UpdateUser attribute)

from_dict() (kittycad.models.update_user.UpdateUser class method)

__init__([company, discord, first_name, ...])

Method generated by attrs for class UpdateUser.

rtype

TypeVar(QZ, bound= UpdateUser)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.update_user.UpdateUser.__init__>`\ \(\[company\, discord\, first\_name\, ...\]\)

:py:obj:`to_dict <kittycad.models.update_user.UpdateUser.to_dict>`\ \(\)

company

discord

github

last_name

phone

:py:obj:`User <kittycad.models.user.User>`\ \(\[company\, created\_at\, discord\, email\, ...\]\)

User(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

{'additional_properties': typing.Dict[str, typing.Any], 'company': typing.Union[kittycad.types.Unset, str], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'discord': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str], 'email_verified': typing.Union[kittycad.types.Unset, datetime.datetime], 'first_name': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'image': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime]}

(Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='email_verified', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email_verified'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='image', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='image'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

mappingproxy({'__module__': 'kittycad.models.user', '__annotations__': {'company': typing.Union[kittycad.types.Unset, str], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'discord': typing.Union[kittycad.types.Unset, str], 'email': typing.Union[kittycad.types.Unset, str], 'email_verified': typing.Union[kittycad.types.Unset, datetime.datetime], 'first_name': typing.Union[kittycad.types.Unset, str], 'github': typing.Union[kittycad.types.Unset, str], 'id': typing.Union[kittycad.types.Unset, str], 'image': typing.Union[kittycad.types.Unset, str], 'last_name': typing.Union[kittycad.types.Unset, str], 'name': typing.Union[kittycad.types.Unset, str], 'phone': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A user.', 'to_dict': <function User.to_dict>, 'from_dict': <classmethod(<function User.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function User.__getitem__>, '__setitem__': <function User.__setitem__>, '__delitem__': <function User.__delitem__>, '__contains__': <function User.__contains__>, '__dict__': <attribute '__dict__' of 'User' objects>, '__weakref__': <attribute '__weakref__' of 'User' objects>, '__attrs_attrs__': (Attribute(name='company', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='company'), Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='discord', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='discord'), Attribute(name='email', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email'), Attribute(name='email_verified', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='email_verified'), Attribute(name='first_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='first_name'), Attribute(name='github', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='github'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='image', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='image'), Attribute(name='last_name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='last_name'), Attribute(name='name', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='name'), Attribute(name='phone', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='phone'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function User.__repr__>, '__eq__': <function User.__eq__>, '__ne__': <function User.__ne__>, '__lt__': <function User.__lt__>, '__le__': <function User.__le__>, '__gt__': <function User.__gt__>, '__ge__': <function User.__ge__>, '__hash__': None, '__init__': <function User.__init__>, '__match_args__': ('company', 'created_at', 'discord', 'email', 'email_verified', 'first_name', 'github', 'id', 'image', 'last_name', 'name', 'phone', 'updated_at')})

User.__init__(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

('company', 'created_at', 'discord', 'email', 'email_verified', 'first_name', 'github', 'id', 'image', 'last_name', 'name', 'phone', 'updated_at')

Method generated by attrs for class User.

rtype

TypeVar(SY, bound= User)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.user.User.__init__>`\ \(\[company\, created\_at\, discord\, ...\]\)

:py:obj:`from_dict <kittycad.models.user.User.from_dict>`\ \(src\_dict\)

company

discord

email

github

id

image

last_name

name

phone

UserResultsPage([items, next_page])

:py:obj:`UserResultsPage <kittycad.models.user_results_page.UserResultsPage>`\ \(\[items\, next\_page\]\)

UserResultsPage(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

UserResultsPage.User (class in kittycad.models.user_results_page)

UserResultsPage.User(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

__contains__() (kittycad.models.user_results_page.UserResultsPage.User method)

__delitem__() (kittycad.models.user_results_page.UserResultsPage.User method)

__dict__ (kittycad.models.user_results_page.UserResultsPage.User attribute)

__eq__() (kittycad.models.user_results_page.UserResultsPage.User method)

__ge__() (kittycad.models.user_results_page.UserResultsPage.User method)

__getitem__() (kittycad.models.user_results_page.UserResultsPage.User method)

__gt__() (kittycad.models.user_results_page.UserResultsPage.User method)

__hash__ (kittycad.models.user_results_page.UserResultsPage.User attribute)

__init__() (kittycad.models.user_results_page.UserResultsPage.User method)

UserResultsPage.User.__init__(company=<kittycad.types.Unset object>, created_at=<kittycad.types.Unset object>, discord=<kittycad.types.Unset object>, email=<kittycad.types.Unset object>, email_verified=<kittycad.types.Unset object>, first_name=<kittycad.types.Unset object>, github=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, image=<kittycad.types.Unset object>, last_name=<kittycad.types.Unset object>, name=<kittycad.types.Unset object>, phone=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

__le__() (kittycad.models.user_results_page.UserResultsPage.User method)

__lt__() (kittycad.models.user_results_page.UserResultsPage.User method)

__module__ (kittycad.models.user_results_page.UserResultsPage.User attribute)

__ne__() (kittycad.models.user_results_page.UserResultsPage.User method)

__repr__() (kittycad.models.user_results_page.UserResultsPage.User method)

__setitem__() (kittycad.models.user_results_page.UserResultsPage.User method)

company (kittycad.models.user_results_page.UserResultsPage.User attribute)

created_at (kittycad.models.user_results_page.UserResultsPage.User attribute)

discord (kittycad.models.user_results_page.UserResultsPage.User attribute)

email (kittycad.models.user_results_page.UserResultsPage.User attribute)

first_name (kittycad.models.user_results_page.UserResultsPage.User attribute)

from_dict() (kittycad.models.user_results_page.UserResultsPage.User class method)

github (kittycad.models.user_results_page.UserResultsPage.User attribute)

id (kittycad.models.user_results_page.UserResultsPage.User attribute)

image (kittycad.models.user_results_page.UserResultsPage.User attribute)

last_name (kittycad.models.user_results_page.UserResultsPage.User attribute)

name (kittycad.models.user_results_page.UserResultsPage.User attribute)

phone (kittycad.models.user_results_page.UserResultsPage.User attribute)

to_dict() (kittycad.models.user_results_page.UserResultsPage.User method)

updated_at (kittycad.models.user_results_page.UserResultsPage.User attribute)

__annotations__ (kittycad.models.user_results_page.UserResultsPage attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.user.User]], 'next_page': typing.Union[kittycad.types.Unset, str]}

__attrs_attrs__ (kittycad.models.user_results_page.UserResultsPage attribute)

(Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.user.User]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.user_results_page.UserResultsPage method)

__delitem__() (kittycad.models.user_results_page.UserResultsPage method)

__dict__ (kittycad.models.user_results_page.UserResultsPage attribute)

mappingproxy({'__module__': 'kittycad.models.user_results_page', '__annotations__': {'items': typing.Union[kittycad.types.Unset, typing.List[kittycad.models.user.User]], 'next_page': typing.Union[kittycad.types.Unset, str], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': 'A single page of results', 'User': <class 'kittycad.models.user.User'>, 'to_dict': <function UserResultsPage.to_dict>, 'from_dict': <classmethod(<function UserResultsPage.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function UserResultsPage.__getitem__>, '__setitem__': <function UserResultsPage.__setitem__>, '__delitem__': <function UserResultsPage.__delitem__>, '__contains__': <function UserResultsPage.__contains__>, '__dict__': <attribute '__dict__' of 'UserResultsPage' objects>, '__weakref__': <attribute '__weakref__' of 'UserResultsPage' objects>, '__attrs_attrs__': (Attribute(name='items', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, typing.List[kittycad.models.user.User]], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='items'), Attribute(name='next_page', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='next_page'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function UserResultsPage.__repr__>, '__eq__': <function UserResultsPage.__eq__>, '__ne__': <function UserResultsPage.__ne__>, '__lt__': <function UserResultsPage.__lt__>, '__le__': <function UserResultsPage.__le__>, '__gt__': <function UserResultsPage.__gt__>, '__ge__': <function UserResultsPage.__ge__>, '__hash__': None, '__init__': <function UserResultsPage.__init__>, '__match_args__': ('items', 'next_page')})

__eq__() (kittycad.models.user_results_page.UserResultsPage method)

__ge__() (kittycad.models.user_results_page.UserResultsPage method)

__getitem__() (kittycad.models.user_results_page.UserResultsPage method)

__gt__() (kittycad.models.user_results_page.UserResultsPage method)

__hash__ (kittycad.models.user_results_page.UserResultsPage attribute)

__init__() (kittycad.models.user_results_page.UserResultsPage method)

UserResultsPage.__init__(items=<kittycad.types.Unset object>, next_page=<kittycad.types.Unset object>)

__le__() (kittycad.models.user_results_page.UserResultsPage method)

__lt__() (kittycad.models.user_results_page.UserResultsPage method)

__match_args__ (kittycad.models.user_results_page.UserResultsPage attribute)

__module__ (kittycad.models.user_results_page.UserResultsPage attribute)

__ne__() (kittycad.models.user_results_page.UserResultsPage method)

__repr__() (kittycad.models.user_results_page.UserResultsPage method)

__setitem__() (kittycad.models.user_results_page.UserResultsPage method)

additional_keys (kittycad.models.user_results_page.UserResultsPage property)

from_dict() (kittycad.models.user_results_page.UserResultsPage class method)

items (kittycad.models.user_results_page.UserResultsPage attribute)

next_page (kittycad.models.user_results_page.UserResultsPage attribute)

to_dict() (kittycad.models.user_results_page.UserResultsPage method)

Method generated by attrs for class UserResultsPage.

rtype

TypeVar(YK, bound= UserResultsPage)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.user_results_page.UserResultsPage.__init__>`\ \(\[items\, next\_page\]\)

mappingproxy({'__module__': 'kittycad.models.uuid', '__str__': <function Uuid.__str__>, '__dict__': <attribute '__dict__' of 'Uuid' objects>, '__weakref__': <attribute '__weakref__' of 'Uuid' objects>, '__doc__': None, '__annotations__': {}})

:py:obj:`capitalize <kittycad.models.uuid.Uuid.capitalize>`\ \(\)

:py:obj:`center <kittycad.models.uuid.Uuid.center>`\ \(width\[\, fillchar\]\)

:py:obj:`count <kittycad.models.uuid.Uuid.count>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`encode <kittycad.models.uuid.Uuid.encode>`\ \(\[encoding\, errors\]\)

:py:obj:`endswith <kittycad.models.uuid.Uuid.endswith>`\ \(suffix\[\, start\[\, end\]\]\)

:py:obj:`expandtabs <kittycad.models.uuid.Uuid.expandtabs>`\ \(\[tabsize\]\)

:py:obj:`find <kittycad.models.uuid.Uuid.find>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`format <kittycad.models.uuid.Uuid.format>`\ \(\*args\, \*\*kwargs\)

:py:obj:`format_map <kittycad.models.uuid.Uuid.format_map>`\ \(mapping\)

:py:obj:`index <kittycad.models.uuid.Uuid.index>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`isidentifier <kittycad.models.uuid.Uuid.isidentifier>`\ \(\)

:py:obj:`isprintable <kittycad.models.uuid.Uuid.isprintable>`\ \(\)

:py:obj:`join <kittycad.models.uuid.Uuid.join>`\ \(iterable\, \/\)

:py:obj:`ljust <kittycad.models.uuid.Uuid.ljust>`\ \(width\[\, fillchar\]\)

:py:obj:`lstrip <kittycad.models.uuid.Uuid.lstrip>`\ \(\[chars\]\)

:py:obj:`partition <kittycad.models.uuid.Uuid.partition>`\ \(sep\, \/\)

:py:obj:`removeprefix <kittycad.models.uuid.Uuid.removeprefix>`\ \(prefix\, \/\)

:py:obj:`removesuffix <kittycad.models.uuid.Uuid.removesuffix>`\ \(suffix\, \/\)

:py:obj:`replace <kittycad.models.uuid.Uuid.replace>`\ \(old\, new\[\, count\]\)

:py:obj:`rfind <kittycad.models.uuid.Uuid.rfind>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rindex <kittycad.models.uuid.Uuid.rindex>`\ \(sub\[\, start\[\, end\]\]\)

:py:obj:`rjust <kittycad.models.uuid.Uuid.rjust>`\ \(width\[\, fillchar\]\)

:py:obj:`rpartition <kittycad.models.uuid.Uuid.rpartition>`\ \(sep\, \/\)

:py:obj:`rsplit <kittycad.models.uuid.Uuid.rsplit>`\ \(\[sep\, maxsplit\]\)

:py:obj:`rstrip <kittycad.models.uuid.Uuid.rstrip>`\ \(\[chars\]\)

:py:obj:`split <kittycad.models.uuid.Uuid.split>`\ \(\[sep\, maxsplit\]\)

:py:obj:`splitlines <kittycad.models.uuid.Uuid.splitlines>`\ \(\[keepends\]\)

:py:obj:`startswith <kittycad.models.uuid.Uuid.startswith>`\ \(prefix\[\, start\[\, end\]\]\)

:py:obj:`strip <kittycad.models.uuid.Uuid.strip>`\ \(\[chars\]\)

:py:obj:`translate <kittycad.models.uuid.Uuid.translate>`\ \(table\, \/\)

:py:obj:`zfill <kittycad.models.uuid.Uuid.zfill>`\ \(width\, \/\)

VerificationToken([created_at, expires, id, ...])

A verification token for a user.

:py:obj:`VerificationToken <kittycad.models.verification_token.VerificationToken>`\ \(\[created\_at\, expires\, id\, ...\]\)

VerificationToken(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, identifier=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, identifier=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

__annotations__ (kittycad.models.verification_token.VerificationToken attribute)

{'additional_properties': typing.Dict[str, typing.Any], 'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'expires': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'identifier': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime]}

__attrs_attrs__ (kittycad.models.verification_token.VerificationToken attribute)

(Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='expires', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expires'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='identifier', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='identifier'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties'))

__contains__() (kittycad.models.verification_token.VerificationToken method)

__delitem__() (kittycad.models.verification_token.VerificationToken method)

__dict__ (kittycad.models.verification_token.VerificationToken attribute)

mappingproxy({'__module__': 'kittycad.models.verification_token', '__annotations__': {'created_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'expires': typing.Union[kittycad.types.Unset, datetime.datetime], 'id': typing.Union[kittycad.types.Unset, str], 'identifier': typing.Union[kittycad.types.Unset, str], 'updated_at': typing.Union[kittycad.types.Unset, datetime.datetime], 'additional_properties': typing.Dict[str, typing.Any]}, '__doc__': "A verification token for a user.\n\n    This is typically used to verify a user's email address.", 'to_dict': <function VerificationToken.to_dict>, 'from_dict': <classmethod(<function VerificationToken.from_dict>)>, 'additional_keys': <property object>, '__getitem__': <function VerificationToken.__getitem__>, '__setitem__': <function VerificationToken.__setitem__>, '__delitem__': <function VerificationToken.__delitem__>, '__contains__': <function VerificationToken.__contains__>, '__dict__': <attribute '__dict__' of 'VerificationToken' objects>, '__weakref__': <attribute '__weakref__' of 'VerificationToken' objects>, '__attrs_attrs__': (Attribute(name='created_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='created_at'), Attribute(name='expires', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='expires'), Attribute(name='id', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='id'), Attribute(name='identifier', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='identifier'), Attribute(name='updated_at', default=<kittycad.types.Unset object>, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[kittycad.types.Unset, datetime.datetime], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='updated_at'), Attribute(name='additional_properties', default=Factory(factory=<class 'dict'>, takes_self=False), validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=False, metadata=mappingproxy({}), type=typing.Dict[str, typing.Any], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='additional_properties')), '__repr__': <function VerificationToken.__repr__>, '__eq__': <function VerificationToken.__eq__>, '__ne__': <function VerificationToken.__ne__>, '__lt__': <function VerificationToken.__lt__>, '__le__': <function VerificationToken.__le__>, '__gt__': <function VerificationToken.__gt__>, '__ge__': <function VerificationToken.__ge__>, '__hash__': None, '__init__': <function VerificationToken.__init__>, '__match_args__': ('created_at', 'expires', 'id', 'identifier', 'updated_at')})

__eq__() (kittycad.models.verification_token.VerificationToken method)

__ge__() (kittycad.models.verification_token.VerificationToken method)

__getitem__() (kittycad.models.verification_token.VerificationToken method)

__gt__() (kittycad.models.verification_token.VerificationToken method)

__hash__ (kittycad.models.verification_token.VerificationToken attribute)

__init__() (kittycad.models.verification_token.VerificationToken method)

VerificationToken.__init__(created_at=<kittycad.types.Unset object>, expires=<kittycad.types.Unset object>, id=<kittycad.types.Unset object>, identifier=<kittycad.types.Unset object>, updated_at=<kittycad.types.Unset object>)

__le__() (kittycad.models.verification_token.VerificationToken method)

__lt__() (kittycad.models.verification_token.VerificationToken method)

__match_args__ (kittycad.models.verification_token.VerificationToken attribute)

__module__ (kittycad.models.verification_token.VerificationToken attribute)

__ne__() (kittycad.models.verification_token.VerificationToken method)

__repr__() (kittycad.models.verification_token.VerificationToken method)

__setitem__() (kittycad.models.verification_token.VerificationToken method)

additional_keys (kittycad.models.verification_token.VerificationToken property)

created_at (kittycad.models.verification_token.VerificationToken attribute)

expires (kittycad.models.verification_token.VerificationToken attribute)

from_dict() (kittycad.models.verification_token.VerificationToken class method)

id (kittycad.models.verification_token.VerificationToken attribute)

identifier (kittycad.models.verification_token.VerificationToken attribute)

to_dict() (kittycad.models.verification_token.VerificationToken method)

updated_at (kittycad.models.verification_token.VerificationToken attribute)

Method generated by attrs for class VerificationToken.

rtype

TypeVar(WS, bound= VerificationToken)

to_dict()

rtype

:py:obj:`__init__ <kittycad.models.verification_token.VerificationToken.__init__>`\ \(\[created\_at\, expires\, id\, ...\]\)

expires

id

identifier

File(payload[, file_name, mime_type])

Contains information for file uploads

Response(status_code, content, headers, parsed)

A response from an endpoint

Unset()

:py:obj:`File <kittycad.types.File>`\ \(payload\[\, file\_name\, mime\_type\]\)

:py:obj:`Response <kittycad.types.Response>`\ \(status\_code\, content\, headers\, parsed\)

{'file_name': typing.Optional[str], 'mime_type': typing.Optional[str], 'payload': typing.Union[typing.BinaryIO, typing.TextIO]}

(Attribute(name='payload', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[typing.BinaryIO, typing.TextIO], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='payload'), Attribute(name='file_name', default=None, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='file_name'), Attribute(name='mime_type', default=None, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mime_type'))

mappingproxy({'__module__': 'kittycad.types', '__annotations__': {'payload': typing.Union[typing.BinaryIO, typing.TextIO], 'file_name': typing.Optional[str], 'mime_type': typing.Optional[str]}, '__doc__': 'Contains information for file uploads', 'to_tuple': <function File.to_tuple>, '__dict__': <attribute '__dict__' of 'File' objects>, '__weakref__': <attribute '__weakref__' of 'File' objects>, '__attrs_attrs__': (Attribute(name='payload', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Union[typing.BinaryIO, typing.TextIO], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='payload'), Attribute(name='file_name', default=None, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='file_name'), Attribute(name='mime_type', default=None, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='mime_type')), '__repr__': <function File.__repr__>, '__eq__': <function File.__eq__>, '__ne__': <function File.__ne__>, '__lt__': <function File.__lt__>, '__le__': <function File.__le__>, '__gt__': <function File.__gt__>, '__ge__': <function File.__ge__>, '__hash__': None, '__init__': <function File.__init__>, '__match_args__': ('payload', 'file_name', 'mime_type')})

Return a tuple representation that httpx will accept for multipart/form-data

{'content': <class 'bytes'>, 'headers': typing.MutableMapping[str, str], 'parsed': typing.Optional[~T], 'status_code': <class 'int'>}

(Attribute(name='status_code', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'int'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='content', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'bytes'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='content'), Attribute(name='headers', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.MutableMapping[str, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='headers'), Attribute(name='parsed', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[~T], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='parsed'))

At least, parameterizing a generic class is the *main* thing this method
does. For example, for some generic class `Foo`, this is called when we
do `Foo[int]` - there, with `cls=Foo` and `params=int`.

However, note that this method is also called when defining generic
classes in the first place with `class Foo(Generic[T]): ...`.

classes in the first place with 

mappingproxy({'__module__': 'kittycad.types', '__annotations__': {'status_code': <class 'int'>, 'content': <class 'bytes'>, 'headers': typing.MutableMapping[str, str], 'parsed': typing.Optional[~T]}, '__doc__': 'A response from an endpoint', '__orig_bases__': (typing.Generic[~T],), '__dict__': <attribute '__dict__' of 'Response' objects>, '__weakref__': <attribute '__weakref__' of 'Response' objects>, '__parameters__': (~T,), '__attrs_attrs__': (Attribute(name='status_code', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'int'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='status_code'), Attribute(name='content', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'bytes'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='content'), Attribute(name='headers', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.MutableMapping[str, str], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='headers'), Attribute(name='parsed', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=typing.Optional[~T], converter=None, kw_only=False, inherited=False, on_setattr=None, alias='parsed')), '__repr__': <function Response.__repr__>, '__eq__': <function Response.__eq__>, '__ne__': <function Response.__ne__>, '__lt__': <function Response.__lt__>, '__le__': <function Response.__le__>, '__gt__': <function Response.__gt__>, '__ge__': <function Response.__ge__>, '__hash__': None, '__init__': <function Response.__init__>, '__match_args__': ('status_code', 'content', 'headers', 'parsed')})

The default implementation does nothing. It may be
overridden to extend subclasses.

__init__(payload[, file_name, mime_type])

Method generated by attrs for class File.

to_tuple()

:py:obj:`__init__ <kittycad.types.File.__init__>`\ \(payload\[\, file\_name\, mime\_type\]\)

Bases: :py:class:`~typing.Generic`\ [:py:obj:`~kittycad.types.T`]

__init__(status_code, content, headers, parsed)

Method generated by attrs for class Response.

:py:obj:`__init__ <kittycad.types.Response.__init__>`\ \(status\_code\, content\, headers\, parsed\)

mappingproxy({'__module__': 'kittycad.types', '__bool__': <function Unset.__bool__>, '__dict__': <attribute '__dict__' of 'Unset' objects>, '__weakref__': <attribute '__weakref__' of 'Unset' objects>, '__doc__': None, '__annotations__': {}})

kittycad documentation master file, created by
sphinx-quickstart on Wed Dec 15 10:15:30 2021.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.

kittycad.api

Contains methods for accessing the API

kittycad.client

kittycad.models

Contains all the data models used in inputs/outputs

kittycad.types

Contains some shared types for properties

f-strings support = for self-documenting expressions and debugging

ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON 3.11.4 DOCUMENTATION

email.message.Message: Representing an email message using the compat32 API

What is the most efficient way to concatenate many strings together?

Why does a_tuple[i] += [‘item’] raise an exception when the addition works?

What does the slash(/) in the parameter list of a function mean?

Why am I getting an UnboundLocalError when the variable has a value?

PEP 3118: New memoryview implementation and buffer protocol documentation

PEP 476: Enabling certificate verification by default for stdlib http clients

PEP 471 - os.scandir() function – a better and faster directory iterator

PEP 655: Marking individual TypedDict items as required or not-required

Why must ‘self’ be used explicitly in method definitions and calls?

argparse — Parser for command-line options, arguments and sub-commands

functools — Higher-order functions and operations on callable objects

multiprocessing.shared_memory — Shared memory for direct access across processes

sysconfig — Provide access to Python’s configuration information

from typing import Any, Dict, Optional, Union

import httpx

from ...client import Client
from ...models.error import Error
from ...models.file_export_format import FileExportFormat
from ...models.image_type import ImageType
from ...models.mesh import Mesh
from ...types import Response

def _get_kwargs(
    input_format: ImageType,
    output_format: FileExportFormat,
    body: bytes,
    *,
    client: Client,
) -> Dict[str, Any]:
    url = "{}/ai/image-to-3d/{input_format}/{output_format}".format(
        client.base_url,
        input_format=input_format,
        output_format=output_format,
    )  # noqa: E501

    headers: Dict[str, Any] = client.get_headers()
    cookies: Dict[str, Any] = client.get_cookies()

    return {
        "url": url,
        "headers": headers,
        "cookies": cookies,
        "timeout": client.get_timeout(),
        "content": body,
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Mesh, Error]]:
    if response.status_code == 200:
        response_200 = Mesh.from_dict(response.json())
        return response_200
    if response.status_code == 400:
        response_4XX = Error.from_dict(response.json())
        return response_4XX
    if response.status_code == 500:
        response_5XX = Error.from_dict(response.json())
        return response_5XX
    return Error.from_dict(response.json())

def _build_response(
    *, response: httpx.Response
) -> Response[Optional[Union[Mesh, Error]]]:
    return Response(
        status_code=response.status_code,
        content=response.content,
        headers=response.headers,
        parsed=_parse_response(response=response),
    )

def sync_detailed(
    *,
    kwargs = _get_kwargs(
        body=body,
        client=client,
    )

    response = httpx.post(
        verify=client.verify_ssl,
        **kwargs,
    )

    return _build_response(response=response)

def sync(
    *,
) -> Optional[Union[Mesh, Error]]:
    """This is an alpha endpoint. It will change in the future. The current output is honestly pretty bad. So if you find this endpoint, you get what you pay for, which currently is nothing. But in the future will be made a lot better."""  # noqa: E501

    return sync_detailed(
    ).parsed

async def asyncio_detailed(
    *,
    )

    async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
        response = await _client.post(**kwargs)

async def asyncio(
    *,

    return (
        await asyncio_detailed(
            input_format=input_format,
            output_format=output_format,
            body=body,
            client=client,
        )
    ).parsed

    prompt: str,
    *,
    url = "{}/ai/text-to-3d/{output_format}".format(

    if prompt is not None:
        if "?" in url:
            url = url + "&prompt=" + str(prompt)
        else:
            url = url + "?prompt=" + str(prompt)

    return {
    }

    )

    *,
        prompt=prompt,
    )

        **kwargs,
    )

def sync(
    *,

    ).parsed

    *,
    )

    *,

    return (
            prompt=prompt,
        )
    ).parsed

from ...models.api_call_with_price import ApiCallWithPrice

    id: str,
    *,
    url = "{}/api-calls/{id}".format(
        id=id,

    return {
    }

def _parse_response(
) -> Optional[Union[ApiCallWithPrice, Error]]:
        response_200 = ApiCallWithPrice.from_dict(response.json())

) -> Response[Optional[Union[ApiCallWithPrice, Error]]]:
    )

    id: str,
    *,
        id=id,
    )

    response = httpx.get(
        **kwargs,
    )

def sync(
    id: str,
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns details of the requested API call for the user.
    If the user is not authenticated to view the specified API call, then it is not returned.
    Only KittyCAD employees can view API calls for other users."""  # noqa: E501

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

        response = await _client.get(**kwargs)

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

    id: str,
    *,
    url = "{}/user/api-calls/{id}".format(
        id=id,

    return {
    }

    )

    id: str,
    *,
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns details of the requested API call for the user."""  # noqa: E501

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

from typing import Any, Dict, List, Optional, Union

from ...models.api_call_query_group import ApiCallQueryGroup
from ...models.api_call_query_group_by import ApiCallQueryGroupBy

    group_by: ApiCallQueryGroupBy,
    *,
    url = "{}/api-call-metrics".format(

    if group_by is not None:
            url = url + "&group_by=" + str(group_by)
        else:
            url = url + "?group_by=" + str(group_by)

    return {
    }

) -> Optional[Union[List[ApiCallQueryGroup], Error]]:
        response_200 = [ApiCallQueryGroup.from_dict(item) for item in response.json()]

) -> Response[Optional[Union[List[ApiCallQueryGroup], Error]]]:
    )

    *,
        group_by=group_by,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by a KittyCAD employee. The API calls are grouped by the parameter passed."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
            group_by=group_by,
        )
    ).parsed

from ...models.file_center_of_mass import FileCenterOfMass
from ...models.file_conversion import FileConversion
from ...models.file_density import FileDensity
from ...models.file_mass import FileMass
from ...models.file_surface_area import FileSurfaceArea
from ...models.file_volume import FileVolume

    id: str,
    *,
    url = "{}/async/operations/{id}".format(
        id=id,

    return {
    }

) -> Optional[
    Union[
        FileConversion,
        FileCenterOfMass,
        FileMass,
        FileVolume,
        FileDensity,
        FileSurfaceArea,
        Error,
    ]
]:
        data = response.json()
        try:
            if not isinstance(data, dict):
                raise TypeError()
            option_file_conversion = FileConversion.from_dict(data)
            return option_file_conversion
        except ValueError:
            pass
        except TypeError:
            pass
        try:
            option_file_center_of_mass = FileCenterOfMass.from_dict(data)
            return option_file_center_of_mass
            pass
            pass
        try:
            option_file_mass = FileMass.from_dict(data)
            return option_file_mass
            pass
            pass
        try:
            option_file_volume = FileVolume.from_dict(data)
            return option_file_volume
            pass
            pass
        try:
            option_file_density = FileDensity.from_dict(data)
            return option_file_density
            pass
            pass
        try:
            option_file_surface_area = FileSurfaceArea.from_dict(data)
            return option_file_surface_area
            raise
            raise

) -> Response[
    Optional[
        Union[
            FileConversion,
            FileCenterOfMass,
            FileMass,
            FileVolume,
            FileDensity,
            FileSurfaceArea,
            Error,
        ]
    ]
]:
    )

    id: str,
    *,
    Optional[
        Union[
            FileMass,
            Error,
        ]
    ]
]:
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
    Union[
        FileMass,
        Error,
    ]
]:
    """Get the status and output of an async operation.
    This endpoint requires authentication by any KittyCAD user. It returns details of the requested async operation for the user.
    If the user is not authenticated to view the specified async operation, then it is not returned.
    Only KittyCAD employees with the proper access can view async operations for other users.
    """  # noqa: E501

        id=id,
    ).parsed

    id: str,
    *,
    Optional[
        Union[
            FileMass,
            Error,
        ]
    ]
]:
        id=id,
    )

    id: str,
    *,
    Union[
        FileMass,
        Error,
    ]
]:

    return (
            id=id,
        )
    ).parsed

from ...models.api_call_with_price_results_page import ApiCallWithPriceResultsPage
from ...models.created_at_sort_mode import CreatedAtSortMode

    sort_by: CreatedAtSortMode,
    *,
    limit: Optional[int] = None,
    page_token: Optional[str] = None,
    url = "{}/api-calls".format(

    if limit is not None:
            url = url + "&limit=" + str(limit)
        else:
            url = url + "?limit=" + str(limit)

    if page_token is not None:
            url = url + "&page_token=" + str(page_token)
        else:
            url = url + "?page_token=" + str(page_token)

    if sort_by is not None:
            url = url + "&sort_by=" + str(sort_by)
        else:
            url = url + "?sort_by=" + str(sort_by)

    return {
    }

) -> Optional[Union[ApiCallWithPriceResultsPage, Error]]:
        response_200 = ApiCallWithPriceResultsPage.from_dict(response.json())

) -> Response[Optional[Union[ApiCallWithPriceResultsPage, Error]]]:
    )

    *,
        limit=limit,
        page_token=page_token,
        sort_by=sort_by,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by a KittyCAD employee. The API calls are returned in order of creation, with the most recently created API calls first."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
            limit=limit,
            page_token=page_token,
            sort_by=sort_by,
        )
    ).parsed

    id: str,
    *,
    url = "{}/users/{id}/api-calls".format(
        id=id,

        else:

        else:

        else:

    return {
    }

    )

    id: str,
    *,
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns the API calls for the authenticated user if "me" is passed as the user id.
    Alternatively, you can use the `/user/api-calls` endpoint to get the API calls for your user.
    If the authenticated user is a KittyCAD employee, then the API calls are returned for the user specified by the user id.
    The API calls are returned in order of creation, with the most recently created API calls first.

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

from ...models.api_call_status import ApiCallStatus
from ...models.async_api_call_results_page import AsyncApiCallResultsPage

    status: ApiCallStatus,
    *,
    url = "{}/async/operations".format(

        else:

        else:

        else:

    if status is not None:
            url = url + "&status=" + str(status)
        else:
            url = url + "?status=" + str(status)

    return {
    }

) -> Optional[Union[AsyncApiCallResultsPage, Error]]:
        response_200 = AsyncApiCallResultsPage.from_dict(response.json())

) -> Response[Optional[Union[AsyncApiCallResultsPage, Error]]]:
    )

    *,
        status=status,
    )

        **kwargs,
    )

def sync(
    *,
    """For async file conversion operations, this endpoint does not return the contents of converted files (`output`). To get the contents use the `/async/operations/{id}` endpoint.
    This endpoint requires authentication by a KittyCAD employee."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
            status=status,
        )
    ).parsed

    *,
    url = "{}/user/api-calls".format(

        else:

        else:

        else:

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns the API calls for the authenticated user.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.api_token import ApiToken

    *,
    url = "{}/user/api-tokens".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[ApiToken, Error]]:
    if response.status_code == 201:
        response_201 = ApiToken.from_dict(response.json())
        return response_201

) -> Response[Optional[Union[ApiToken, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[ApiToken, Error]]:
    """This endpoint requires authentication by any KittyCAD user. It creates a new API token for the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from typing import Any, Dict, Optional

    token: str,
    *,
    url = "{}/user/api-tokens/{token}".format(
        token=token,

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Error]:
    return None

def _build_response(*, response: httpx.Response) -> Response[Optional[Error]]:
    )

    *,
) -> Response[Optional[Error]]:
    )

    response = httpx.delete(
        **kwargs,
    )

def sync(
    *,
) -> Optional[Error]:
    """This endpoint requires authentication by any KittyCAD user. It deletes the requested API token for the user.
    This endpoint does not actually delete the API token from the database. It merely marks the token as invalid. We still want to keep the token in the database for historical purposes.

    ).parsed

    *,
    )

        response = await _client.delete(**kwargs)

    *,

    return (
            token=token,
        )
    ).parsed

    *,

    return {
    }

        response_200 = ApiToken.from_dict(response.json())

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns details of the requested API token for the user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.api_token_results_page import ApiTokenResultsPage

    *,

        else:

        else:

        else:

    return {
    }

) -> Optional[Union[ApiTokenResultsPage, Error]]:
        response_200 = ApiTokenResultsPage.from_dict(response.json())

) -> Response[Optional[Union[ApiTokenResultsPage, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It returns the API tokens for the authenticated user.
    The API tokens are returned in order of creation, with the most recently created API tokens first.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/apps/github/callback".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This is different than OAuth 2.0 authentication for users. This endpoint grants access for KittyCAD to access user's repos.
    The user doesn't need KittyCAD OAuth authorization for this endpoint, this is purely for the GitHub permissions to access repos.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.app_client_info import AppClientInfo

    *,
    url = "{}/apps/github/consent".format(

    return {
    }

) -> Optional[Union[AppClientInfo, Error]]:
        response_200 = AppClientInfo.from_dict(response.json())

) -> Response[Optional[Union[AppClientInfo, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/apps/github/webhook".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """These come from the GitHub app."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from typing import Any, Dict

from websockets.client import WebSocketClientProtocol, connect as ws_connect_async
from websockets.sync.client import ClientConnection, connect as ws_connect

    *,
    url = "{}/ws/executor/term".format(client.base_url)  # noqa: E501

    return {
    }

def sync(
    *,
) -> ClientConnection:
    """Attach to a docker container to create an interactive terminal."""  # noqa: E501

    )

    with ws_connect(
        kwargs["url"].replace("https://", "wss://"),
        additional_headers=kwargs["headers"],
    ) as websocket:
        return websocket  # type: ignore

    # Return an error if we got here.
    return Error(message="An error occurred while connecting to the websocket.")

    *,
) -> WebSocketClientProtocol:

    )

    async with ws_connect_async(
        kwargs["url"].replace("https://", "wss://"), extra_headers=kwargs["headers"]
        return websocket

from ...models.code_language import CodeLanguage
from ...models.code_output import CodeOutput

    lang: CodeLanguage,
    *,
    output: Optional[str] = None,
    url = "{}/file/execute/{lang}".format(
        lang=lang,

    if output is not None:
            url = url + "&output=" + str(output)
        else:
            url = url + "?output=" + str(output)

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[CodeOutput, Error]]:
        response_200 = CodeOutput.from_dict(response.json())

) -> Response[Optional[Union[CodeOutput, Error]]]:
    )

    *,
        output=output,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[CodeOutput, Error]]:
    ).parsed

    *,
    )

    *,
    return (
            lang=lang,
            output=output,
        )
    ).parsed

from ...models.file_import_format import FileImportFormat
from ...models.unit_length import UnitLength

    output_unit: UnitLength,
    src_format: FileImportFormat,
    *,
    url = "{}/file/center-of-mass".format(

    if output_unit is not None:
            url = url + "&output_unit=" + str(output_unit)
        else:
            url = url + "?output_unit=" + str(output_unit)

    if src_format is not None:
            url = url + "&src_format=" + str(src_format)
        else:
            url = url + "?src_format=" + str(src_format)

    return {
    }

) -> Optional[Union[FileCenterOfMass, Error]]:
        response_201 = FileCenterOfMass.from_dict(response.json())

) -> Response[Optional[Union[FileCenterOfMass, Error]]]:
    )

    *,
        output_unit=output_unit,
        src_format=src_format,
    )

        **kwargs,
    )

def sync(
    *,
    """We assume any file given to us has one consistent unit throughout. We also assume the file is at the proper scale.
    This endpoint returns the cartesian co-ordinate in world space measure units.
    In the future, we will use the units inside the file if they are given and do any conversions if necessary for the calculation. But currently, that is not supported.
    Get the center of mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.
    If the operation is performed asynchronously, the `id` of the operation will be returned. You can use the `id` returned from the request to get status information about the async operation from the `/async/operations/{id}` endpoint.

    ).parsed

    *,
    )

    *,

    return (
            output_unit=output_unit,
            src_format=src_format,
        )
    ).parsed

    *,
    url = "{}/file/conversion/{src_format}/{output_format}".format(

    return {
    }

) -> Optional[Union[FileConversion, Error]]:
        response_201 = FileConversion.from_dict(response.json())

) -> Response[Optional[Union[FileConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """If you wish to specify the conversion options, use the `/file/conversion` endpoint instead.
    Convert a CAD file from one format to another. If the file being converted is larger than 25MB, it will be performed asynchronously.
    If the conversion is performed synchronously, the contents of the converted file (`output`) will be returned as a base64 encoded string.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

import base64
from typing import Any, Optional, Union

from ...api.file.create_file_conversion import asyncio as fc_asyncio, sync as fc_sync
from ...models import Error, FileConversion, FileExportFormat, FileImportFormat

def sync(
    *,
) -> Optional[Union[Any, FileConversion, Error]]:
    """Convert a CAD file from one format to another. If the file being converted is larger than a certain size it will be performed asynchronously. This function automatically base64 encodes the request body and base64 decodes the request output."""

    encoded = base64.b64encode(body)

    fc = fc_sync(
        body=encoded,
    )

    if isinstance(fc, FileConversion) and fc.output != "":
        if isinstance(fc.output, str):
            b = base64.b64decode(fc.output + "=" * (-len(fc.output) % 4))
            # decode the bytes to a string
            fc.output = b.decode("utf-8")

    return fc

    *,

    fc = await fc_asyncio(
    )

    return fc

from ...models.unit_density import UnitDensity
from ...models.unit_mass import UnitMass

    material_mass: float,
    material_mass_unit: UnitMass,
    output_unit: UnitDensity,
    *,
    url = "{}/file/density".format(

    if material_mass is not None:
            url = url + "&material_mass=" + str(material_mass)
        else:
            url = url + "?material_mass=" + str(material_mass)

    if material_mass_unit is not None:
            url = url + "&material_mass_unit=" + str(material_mass_unit)
        else:
            url = url + "?material_mass_unit=" + str(material_mass_unit)

        else:

        else:

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[FileDensity, Error]]:
        response_201 = FileDensity.from_dict(response.json())

) -> Response[Optional[Union[FileDensity, Error]]]:
    )

    *,
        material_mass=material_mass,
        material_mass_unit=material_mass_unit,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[FileDensity, Error]]:
    This endpoint assumes if you are giving a material mass in a specific mass units, we return a density in mass unit per cubic measure unit.
    Get the density of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

    ).parsed

    *,
    )

    *,

    return (
            material_mass=material_mass,
            material_mass_unit=material_mass_unit,
        )
    ).parsed

    material_density: float,
    material_density_unit: UnitDensity,
    output_unit: UnitMass,
    *,
    url = "{}/file/mass".format(

    if material_density is not None:
            url = url + "&material_density=" + str(material_density)
        else:
            url = url + "?material_density=" + str(material_density)

    if material_density_unit is not None:
            url = url + "&material_density_unit=" + str(material_density_unit)
        else:
            url = url + "?material_density_unit=" + str(material_density_unit)

        else:

        else:

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[FileMass, Error]]:
        response_201 = FileMass.from_dict(response.json())

) -> Response[Optional[Union[FileMass, Error]]]:
    )

    *,
        material_density=material_density,
        material_density_unit=material_density_unit,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[FileMass, Error]]:
    This endpoint assumes if you are giving a material density in a specific mass unit per cubic measure unit, we return a mass in mass units. The same mass units as passed in the material density.
    Get the mass of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

    ).parsed

    *,
    )

    *,

    return (
            material_density=material_density,
            material_density_unit=material_density_unit,
        )
    ).parsed

from ...models.unit_area import UnitArea

    output_unit: UnitArea,
    *,
    url = "{}/file/surface-area".format(

        else:

        else:

    return {
    }

) -> Optional[Union[FileSurfaceArea, Error]]:
        response_201 = FileSurfaceArea.from_dict(response.json())

) -> Response[Optional[Union[FileSurfaceArea, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    This endpoint returns the square measure units.
    Get the surface area of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_volume import UnitVolume

    output_unit: UnitVolume,
    *,
    url = "{}/file/volume".format(

        else:

        else:

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[FileVolume, Error]]:
        response_201 = FileVolume.from_dict(response.json())

) -> Response[Optional[Union[FileVolume, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[FileVolume, Error]]:
    This endpoint returns the cubic measure units.
    Get the volume of an object in a CAD file. If the file is larger than 25MB, it will be performed asynchronously.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...api.api_calls.get_async_operation import asyncio as fc_asyncio, sync as fc_sync
from ...models import Error

def sync(
    id: str,
    *,
    """Get the status of a file conversion. This function automatically base64 decodes the output response if there is one."""

        id=id,
    )

    return fc

    id: str,
    *,

        id=id,
    )

    return fc

from ...models.email_authentication_form import EmailAuthenticationForm
from ...models.verification_token import VerificationToken

    body: EmailAuthenticationForm,
    *,
    url = "{}/auth/email".format(

    return {
    }

) -> Optional[Union[VerificationToken, Error]]:
        response_201 = VerificationToken.from_dict(response.json())

) -> Response[Optional[Union[VerificationToken, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    ).parsed

    *,
    )

    *,
    return (
        )
    ).parsed

    email: str,
    *,
    callback_url: Optional[str] = None,
    url = "{}/auth/email/callback".format(

    if callback_url is not None:
            url = url + "&callback_url=" + str(callback_url)
        else:
            url = url + "?callback_url=" + str(callback_url)

    if email is not None:
            url = url + "&email=" + str(email)
        else:
            url = url + "?email=" + str(email)

    if token is not None:
            url = url + "&token=" + str(token)
        else:
            url = url + "?token=" + str(token)

    return {
    }

    )

    *,
        callback_url=callback_url,
        email=email,
    )

        **kwargs,
    )

def sync(
    *,
    ).parsed

    *,
    )

    *,
    return (
            callback_url=callback_url,
            email=email,
        )
    ).parsed

    *,
    url = "{}/logout".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This is used in logout scenarios."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.ai_plugin_manifest import AiPluginManifest

    *,
    url = "{}/.well-known/ai-plugin.json".format(

    return {
    }

) -> Optional[Union[AiPluginManifest, Error]]:
        response_200 = AiPluginManifest.from_dict(response.json())

) -> Response[Optional[Union[AiPluginManifest, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    ).parsed

    *,
    )

    *,
    return (
        )
    ).parsed

from ...models.metadata import Metadata

    *,
    url = "{}/_meta/info".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Metadata, Error]]:
        response_200 = Metadata.from_dict(response.json())

) -> Response[Optional[Union[Metadata, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[Metadata, Error]]:
    """This includes information on any of our other distributed systems it is connected to.
    You must be a KittyCAD employee to perform this request."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/openai/openapi.json".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[dict, Error]]:
        response_200 = response.json()

) -> Response[Optional[Union[dict, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[dict, Error]]:
    """This is the same as the OpenAPI schema, BUT it has some modifications to make it compatible with OpenAI. For example, descriptions must be < 300 chars."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    ).parsed

    *,
    )

    *,
    return (
        )
    ).parsed

from ...models.pong import Pong

    *,
    url = "{}/ping".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Pong, Error]]:
        response_200 = Pong.from_dict(response.json())

) -> Response[Optional[Union[Pong, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[Pong, Error]]:
    ).parsed

    *,
    )

    *,
    return (
        )
    ).parsed

from ...models.modeling_cmd_req import ModelingCmdReq

    body: ModelingCmdReq,
    *,
    url = "{}/modeling/cmd".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Response depends on which command was submitted, so unfortunately the OpenAPI schema can't generate the right response type."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.modeling_cmd_req_batch import ModelingCmdReqBatch
from ...models.modeling_outcomes import ModelingOutcomes

    body: ModelingCmdReqBatch,
    *,
    url = "{}/modeling/cmd_batch".format(

    return {
    }

) -> Optional[Union[ModelingOutcomes, Error]]:
        response_200 = ModelingOutcomes.from_dict(response.json())

) -> Response[Optional[Union[ModelingOutcomes, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    ).parsed

    *,
    )

    *,
    return (
        )
    ).parsed

    fps: int,
    unlocked_framerate: bool,
    video_res_height: int,
    video_res_width: int,
    *,
    url = "{}/ws/modeling/commands".format(client.base_url)  # noqa: E501

    if fps is not None:
            url = url + "&fps=" + str(fps)
        else:
            url = url + "?fps=" + str(fps)

    if unlocked_framerate is not None:
            url = url + "&unlocked_framerate=" + str(unlocked_framerate)
        else:
            url = url + "?unlocked_framerate=" + str(unlocked_framerate)

    if video_res_height is not None:
            url = url + "&video_res_height=" + str(video_res_height)
        else:
            url = url + "?video_res_height=" + str(video_res_height)

    if video_res_width is not None:
            url = url + "&video_res_width=" + str(video_res_width)
        else:
            url = url + "?video_res_width=" + str(video_res_width)

    return {
    }

def sync(
    fps: int,
    *,
    """Pass those commands to the engine via websocket, and pass responses back to the client. Basically, this is a websocket proxy between the frontend/client and the engine."""  # noqa: E501

        fps=fps,
        unlocked_framerate=unlocked_framerate,
        video_res_height=video_res_height,
        video_res_width=video_res_width,
    )

    fps: int,
    *,

        fps=fps,
    )

from ...models.billing_info import BillingInfo
from ...models.customer import Customer

    body: BillingInfo,
    *,
    url = "{}/user/payment".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Customer, Error]]:
        response_201 = Customer.from_dict(response.json())

) -> Response[Optional[Union[Customer, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[Customer, Error]]:
    """This includes billing address, phone, and name.
    This endpoint requires authentication by any KittyCAD user. It creates the payment information for the authenticated user.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.payment_intent import PaymentIntent

    *,
    url = "{}/user/payment/intent".format(

    return {
    }

) -> Optional[Union[PaymentIntent, Error]]:
        response_201 = PaymentIntent.from_dict(response.json())

) -> Response[Optional[Union[PaymentIntent, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It creates a new payment intent for the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    This endpoint requires authentication by any KittyCAD user. It deletes the payment information for the authenticated user.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    id: str,
    *,
    url = "{}/user/payment/methods/{id}".format(
        id=id,

    return {
    }

    )

    id: str,
    *,
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
    """This endpoint requires authentication by any KittyCAD user. It deletes the specified payment method for the authenticated user."""  # noqa: E501

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

from ...models.customer_balance import CustomerBalance

    *,
    url = "{}/user/payment/balance".format(

    return {
    }

) -> Optional[Union[CustomerBalance, Error]]:
        response_200 = CustomerBalance.from_dict(response.json())

) -> Response[Optional[Union[CustomerBalance, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It gets the balance information for the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,

    return {
    }

        response_200 = Customer.from_dict(response.json())

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    This endpoint requires authentication by any KittyCAD user. It gets the payment information for the authenticated user.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.invoice import Invoice

    *,
    url = "{}/user/payment/invoices".format(

    return {
    }

) -> Optional[Union[List[Invoice], Error]]:
        response_200 = [Invoice.from_dict(item) for item in response.json()]

) -> Response[Optional[Union[List[Invoice], Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It lists invoices for the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.payment_method import PaymentMethod

    *,
    url = "{}/user/payment/methods".format(

    return {
    }

) -> Optional[Union[List[PaymentMethod], Error]]:
        response_200 = [PaymentMethod.from_dict(item) for item in response.json()]

) -> Response[Optional[Union[List[PaymentMethod], Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It lists payment methods for the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,

    return {
    }

    )

    *,
    )

    response = httpx.put(
        **kwargs,
    )

def sync(
    *,
    This endpoint requires authentication by any KittyCAD user. It updates the payment information for the authenticated user.

    ).parsed

    *,
    )

        response = await _client.put(**kwargs)

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/user/payment/tax".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It will return an error if the customer's information is not valid for automatic tax. Otherwise, it will return an empty successful response."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_angle import UnitAngle
from ...models.unit_angle_conversion import UnitAngleConversion

    input_unit: UnitAngle,
    output_unit: UnitAngle,
    value: float,
    *,
    url = "{}/unit/conversion/angle/{input_unit}/{output_unit}".format(
        input_unit=input_unit,

    if value is not None:
            url = url + "&value=" + str(value)
        else:
            url = url + "?value=" + str(value)

    return {
    }

) -> Optional[Union[UnitAngleConversion, Error]]:
        response_200 = UnitAngleConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitAngleConversion, Error]]]:
    )

    *,
        value=value,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert an angle unit value to another angle unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
            input_unit=input_unit,
            value=value,
        )
    ).parsed

from ...models.unit_area_conversion import UnitAreaConversion

    input_unit: UnitArea,
    *,
    url = "{}/unit/conversion/area/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitAreaConversion, Error]]:
        response_200 = UnitAreaConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitAreaConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert an area unit value to another area unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_current import UnitCurrent
from ...models.unit_current_conversion import UnitCurrentConversion

    input_unit: UnitCurrent,
    output_unit: UnitCurrent,
    *,
    url = "{}/unit/conversion/current/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitCurrentConversion, Error]]:
        response_200 = UnitCurrentConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitCurrentConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a current unit value to another current unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_energy import UnitEnergy
from ...models.unit_energy_conversion import UnitEnergyConversion

    input_unit: UnitEnergy,
    output_unit: UnitEnergy,
    *,
    url = "{}/unit/conversion/energy/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitEnergyConversion, Error]]:
        response_200 = UnitEnergyConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitEnergyConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a energy unit value to another energy unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_force import UnitForce
from ...models.unit_force_conversion import UnitForceConversion

    input_unit: UnitForce,
    output_unit: UnitForce,
    *,
    url = "{}/unit/conversion/force/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitForceConversion, Error]]:
        response_200 = UnitForceConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitForceConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a force unit value to another force unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_frequency import UnitFrequency
from ...models.unit_frequency_conversion import UnitFrequencyConversion

    input_unit: UnitFrequency,
    output_unit: UnitFrequency,
    *,
    url = "{}/unit/conversion/frequency/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitFrequencyConversion, Error]]:
        response_200 = UnitFrequencyConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitFrequencyConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a frequency unit value to another frequency unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_length_conversion import UnitLengthConversion

    input_unit: UnitLength,
    *,
    url = "{}/unit/conversion/length/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitLengthConversion, Error]]:
        response_200 = UnitLengthConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitLengthConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a length unit value to another length unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_mass_conversion import UnitMassConversion

    input_unit: UnitMass,
    *,
    url = "{}/unit/conversion/mass/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitMassConversion, Error]]:
        response_200 = UnitMassConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitMassConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a mass unit value to another mass unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_power import UnitPower
from ...models.unit_power_conversion import UnitPowerConversion

    input_unit: UnitPower,
    output_unit: UnitPower,
    *,
    url = "{}/unit/conversion/power/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitPowerConversion, Error]]:
        response_200 = UnitPowerConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitPowerConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a power unit value to another power unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_pressure import UnitPressure
from ...models.unit_pressure_conversion import UnitPressureConversion

    input_unit: UnitPressure,
    output_unit: UnitPressure,
    *,
    url = "{}/unit/conversion/pressure/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitPressureConversion, Error]]:
        response_200 = UnitPressureConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitPressureConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a pressure unit value to another pressure unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_temperature import UnitTemperature
from ...models.unit_temperature_conversion import UnitTemperatureConversion

    input_unit: UnitTemperature,
    output_unit: UnitTemperature,
    *,
    url = "{}/unit/conversion/temperature/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitTemperatureConversion, Error]]:
        response_200 = UnitTemperatureConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitTemperatureConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a temperature unit value to another temperature unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_torque import UnitTorque
from ...models.unit_torque_conversion import UnitTorqueConversion

    input_unit: UnitTorque,
    output_unit: UnitTorque,
    *,
    url = "{}/unit/conversion/torque/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitTorqueConversion, Error]]:
        response_200 = UnitTorqueConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitTorqueConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a torque unit value to another torque unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.unit_volume_conversion import UnitVolumeConversion

    input_unit: UnitVolume,
    *,
    url = "{}/unit/conversion/volume/{input_unit}/{output_unit}".format(

        else:

    return {
    }

) -> Optional[Union[UnitVolumeConversion, Error]]:
        response_200 = UnitVolumeConversion.from_dict(response.json())

) -> Response[Optional[Union[UnitVolumeConversion, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Convert a volume unit value to another volume unit value. This is a nice endpoint to use for helper functions."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/user".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It deletes the authenticated user from KittyCAD's database.
    This call will only succeed if all invoices associated with the user have been paid in full and there is no outstanding balance.

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.session import Session

    *,
    url = "{}/user/session/{token}".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Session, Error]]:
        response_200 = Session.from_dict(response.json())

) -> Response[Optional[Union[Session, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[Session, Error]]:

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.user import User

    id: str,
    *,
    url = "{}/users/{id}".format(
        id=id,

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[User, Error]]:
        response_200 = User.from_dict(response.json())

) -> Response[Optional[Union[User, Error]]]:
    )

    id: str,
    *,
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
) -> Optional[Union[User, Error]]:
    """To get information about yourself, use `/users/me` as the endpoint. By doing so you will get the user information for the authenticated user.
    Alternatively, to get information about the authenticated user, use `/user` endpoint.
    To get information about any KittyCAD user, you must be a KittyCAD employee."""  # noqa: E501

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

from ...models.extended_user import ExtendedUser

    id: str,
    *,
    url = "{}/users-extended/{id}".format(
        id=id,

    return {
    }

) -> Optional[Union[ExtendedUser, Error]]:
        response_200 = ExtendedUser.from_dict(response.json())

) -> Response[Optional[Union[ExtendedUser, Error]]]:
    )

    id: str,
    *,
        id=id,
    )

        **kwargs,
    )

def sync(
    id: str,
    *,
    """To get information about yourself, use `/users-extended/me` as the endpoint. By doing so you will get the user information for the authenticated user.
    Alternatively, to get information about the authenticated user, use `/user/extended` endpoint.

        id=id,
    ).parsed

    id: str,
    *,
        id=id,
    )

    id: str,
    *,

    return (
            id=id,
        )
    ).parsed

    *,
    url = "{}/user/front-hash".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[str, Error]]:
        response_200 = response.text

) -> Response[Optional[Union[str, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[str, Error]]:
    """This info is sent to front when initialing the front chat, it prevents impersonations using js hacks in the browser"""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.onboarding import Onboarding

    *,
    url = "{}/user/onboarding".format(

    return {
    }

def _parse_response(*, response: httpx.Response) -> Optional[Union[Onboarding, Error]]:
        response_200 = Onboarding.from_dict(response.json())

) -> Response[Optional[Union[Onboarding, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
) -> Optional[Union[Onboarding, Error]]:
    """Checks key part of their api usage to determine their onboarding progress"""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """Get the user information for the authenticated user.
    Alternatively, you can also use the `/users/me` endpoint."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

    *,
    url = "{}/user/extended".format(

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    Alternatively, you can also use the `/users-extended/me` endpoint."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.user_results_page import UserResultsPage

    *,
    url = "{}/users".format(

        else:

        else:

        else:

    return {
    }

) -> Optional[Union[UserResultsPage, Error]]:
        response_200 = UserResultsPage.from_dict(response.json())

) -> Response[Optional[Union[UserResultsPage, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint required authentication by a KittyCAD employee. The users are returned in order of creation, with the most recently created users first."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.extended_user_results_page import ExtendedUserResultsPage

    *,
    url = "{}/users-extended".format(

        else:

        else:

        else:

    return {
    }

) -> Optional[Union[ExtendedUserResultsPage, Error]]:
        response_200 = ExtendedUserResultsPage.from_dict(response.json())

) -> Response[Optional[Union[ExtendedUserResultsPage, Error]]]:
    )

    *,
    )

        **kwargs,
    )

def sync(
    *,

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

from ...models.update_user import UpdateUser

    body: UpdateUser,
    *,

    return {
    }

    )

    *,
    )

        **kwargs,
    )

def sync(
    *,
    """This endpoint requires authentication by any KittyCAD user. It updates information about the authenticated user."""  # noqa: E501

    ).parsed

    *,
    )

    *,

    return (
        )
    ).parsed

import os
import ssl
from typing import Dict, Optional, Union

import attr

@attr.s(auto_attribs=True)
class Client:
    """A Client which has been authenticated for use on secured endpoints of the KittyCAD API."""  # noqa: E501

    token: str = attr.ib(kw_only=True)
    base_url: str = attr.ib(default="https://api.kittycad.io")
    cookies: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
    headers: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
    timeout: float = attr.ib(50.0, kw_only=True)
    verify_ssl: Union[str, bool, ssl.SSLContext] = attr.ib(True, kw_only=True)

    def get_headers(self) -> Dict[str, str]:
        """Get headers to be used in all endpoints"""
        return {"Authorization": f"Bearer {self.token}", **self.headers}

    def with_headers(self, headers: Dict[str, str]) -> "Client":
        """Get a new client matching this one with additional headers"""
        return attr.evolve(self, headers={**self.headers, **headers})

    def get_cookies(self) -> Dict[str, str]:
        return {**self.cookies}

    def with_cookies(self, cookies: Dict[str, str]) -> "Client":
        """Get a new client matching this one with additional cookies"""
        return attr.evolve(self, cookies={**self.cookies, **cookies})

    def get_timeout(self) -> float:
        return self.timeout

    def with_timeout(self, timeout: float) -> "Client":
        """Get a new client matching this one with a new timeout (in seconds)"""
        return attr.evolve(self, timeout=timeout)

class ClientFromEnv(Client):
    """A Client which has been authenticated for use on secured endpoints that uses the KITTYCAD_API_TOKEN environment variable for the authentication token."""  # noqa: E501

    token: str = attr.field()

    @token.default
    def set_token(self):
        maybe_token: Optional[str] = os.getenv("KITTYCAD_API_TOKEN")
        if maybe_token is None:
            raise ValueError(
                "KITTYCAD_API_TOKEN environment variable must be set to use ClientFromEnv"
            )
        token: str = maybe_token
        return token

        """Get headers to be used in authenticated endpoints"""

from enum import Enum

class AccountProvider(str, Enum):
    """An account provider."""  # noqa: E501

    """# The Google account provider. """  # noqa: E501
    GOOGLE = "google"
    """# The GitHub account provider. """  # noqa: E501
    GITHUB = "github"

    def __str__(self) -> str:
        return str(self.value)

from typing import Any, Dict, List, Type, TypeVar, Union

from ..models.ai_plugin_api_type import AiPluginApiType
from ..types import UNSET, Unset

SB = TypeVar("SB", bound="AiPluginApi")

class AiPluginApi:
    """AI plugin api information."""  # noqa: E501

    is_user_authenticated: Union[Unset, bool] = False
    type: Union[Unset, AiPluginApiType] = UNSET
    url: Union[Unset, str] = UNSET

    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

    def to_dict(self) -> Dict[str, Any]:
        is_user_authenticated = self.is_user_authenticated
        if not isinstance(self.type, Unset):
            type = self.type
        url = self.url

        field_dict: Dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update({})
        if is_user_authenticated is not UNSET:
            field_dict["is_user_authenticated"] = is_user_authenticated
        if type is not UNSET:
            field_dict["type"] = type
        if url is not UNSET:
            field_dict["url"] = url

        return field_dict

    @classmethod
    def from_dict(cls: Type[SB], src_dict: Dict[str, Any]) -> SB:
        d = src_dict.copy()
        is_user_authenticated = d.pop("is_user_authenticated", UNSET)

        _type = d.pop("type", UNSET)
        type: Union[Unset, AiPluginApiType]
        if isinstance(_type, Unset):
            type = UNSET
        else:
            type = _type  # type: ignore[arg-type]

        url = d.pop("url", UNSET)

        ai_plugin_api = cls(
            is_user_authenticated=is_user_authenticated,
            type=type,
            url=url,
        )

        ai_plugin_api.additional_properties = d
        return ai_plugin_api

    @property
    def additional_keys(self) -> List[str]:
        return list(self.additional_properties.keys())

    def __getitem__(self, key: str) -> Any:
        return self.additional_properties[key]

    def __setitem__(self, key: str, value: Any) -> None:
        self.additional_properties[key] = value

    def __delitem__(self, key: str) -> None:
        del self.additional_properties[key]

    def __contains__(self, key: str) -> bool:
        return key in self.additional_properties

class AiPluginApiType(str, Enum):
    """AI plugin api type."""  # noqa: E501

    """# An OpenAPI specification. """  # noqa: E501
    OPENAPI = "openapi"

from ..models.ai_plugin_auth_type import AiPluginAuthType
from ..models.ai_plugin_http_auth_type import AiPluginHttpAuthType

NP = TypeVar("NP", bound="AiPluginAuth")

class AiPluginAuth:
    """AI plugin auth information."""  # noqa: E501

    authorization_type: Union[Unset, AiPluginHttpAuthType] = UNSET
    type: Union[Unset, AiPluginAuthType] = UNSET

        if not isinstance(self.authorization_type, Unset):
            authorization_type = self.authorization_type

        if authorization_type is not UNSET:
            field_dict["authorization_type"] = authorization_type

    def from_dict(cls: Type[NP], src_dict: Dict[str, Any]) -> NP:
        _authorization_type = d.pop("authorization_type", UNSET)
        authorization_type: Union[Unset, AiPluginHttpAuthType]
        if isinstance(_authorization_type, Unset):
            authorization_type = UNSET
        else:
            authorization_type = _authorization_type  # type: ignore[arg-type]

        type: Union[Unset, AiPluginAuthType]
        else:

        ai_plugin_auth = cls(
            authorization_type=authorization_type,
        )

        ai_plugin_auth.additional_properties = d
        return ai_plugin_auth

    @property

class AiPluginAuthType(str, Enum):
    """AI plugin auth type."""  # noqa: E501

    """# None. """  # noqa: E501
    NONE = "none"
    """# User http. """  # noqa: E501
    USER_HTTP = "user_http"
    """# Service http. """  # noqa: E501
    SERVICE_HTTP = "service_http"
    """# OAuth. """  # noqa: E501
    OAUTH = "oauth"

class AiPluginHttpAuthType(str, Enum):
    """AI plugin http auth type."""  # noqa: E501

    """# Basic. """  # noqa: E501
    BASIC = "basic"
    """# Bearer. """  # noqa: E501
    BEARER = "bearer"

from ..models.ai_plugin_api import AiPluginApi
from ..models.ai_plugin_auth import AiPluginAuth

SA = TypeVar("SA", bound="AiPluginManifest")

class AiPluginManifest:
    """AI plugin manifest.

    This is used for OpenAI's ChatGPT plugins. You can read more about them [here](https://platform.openai.com/docs/plugins/getting-started/plugin-manifest).

    api: Union[Unset, AiPluginApi] = UNSET
    auth: Union[Unset, AiPluginAuth] = UNSET
    contact_email: Union[Unset, str] = UNSET
    description_for_human: Union[Unset, str] = UNSET
    description_for_model: Union[Unset, str] = UNSET
    legal_info_url: Union[Unset, str] = UNSET
    logo_url: Union[Unset, str] = UNSET
    name_for_human: Union[Unset, str] = UNSET
    name_for_model: Union[Unset, str] = UNSET
    schema_version: Union[Unset, str] = UNSET

        if not isinstance(self.api, Unset):
            api = self.api
        if not isinstance(self.auth, Unset):
            auth = self.auth
        contact_email = self.contact_email
        description_for_human = self.description_for_human
        description_for_model = self.description_for_model
        legal_info_url = self.legal_info_url
        logo_url = self.logo_url
        name_for_human = self.name_for_human
        name_for_model = self.name_for_model
        schema_version = self.schema_version

        if api is not UNSET:
            field_dict["api"] = api
        if auth is not UNSET:
            field_dict["auth"] = auth
        if contact_email is not UNSET:
            field_dict["contact_email"] = contact_email
        if description_for_human is not UNSET:
            field_dict["description_for_human"] = description_for_human
        if description_for_model is not UNSET:
            field_dict["description_for_model"] = description_for_model
        if legal_info_url is not UNSET:
            field_dict["legal_info_url"] = legal_info_url
        if logo_url is not UNSET:
            field_dict["logo_url"] = logo_url
        if name_for_human is not UNSET:
            field_dict["name_for_human"] = name_for_human
        if name_for_model is not UNSET:
            field_dict["name_for_model"] = name_for_model
        if schema_version is not UNSET:
            field_dict["schema_version"] = schema_version

    def from_dict(cls: Type[SA], src_dict: Dict[str, Any]) -> SA:
        _api = d.pop("api", UNSET)
        api: Union[Unset, AiPluginApi]
        if isinstance(_api, Unset):
            api = UNSET
        else:
            api = _api  # type: ignore[arg-type]

        _auth = d.pop("auth", UNSET)
        auth: Union[Unset, AiPluginAuth]
        if isinstance(_auth, Unset):
            auth = UNSET
        else:
            auth = _auth  # type: ignore[arg-type]

        contact_email = d.pop("contact_email", UNSET)

        description_for_human = d.pop("description_for_human", UNSET)

        description_for_model = d.pop("description_for_model", UNSET)

        legal_info_url = d.pop("legal_info_url", UNSET)

        logo_url = d.pop("logo_url", UNSET)

        name_for_human = d.pop("name_for_human", UNSET)

        name_for_model = d.pop("name_for_model", UNSET)

        schema_version = d.pop("schema_version", UNSET)

        ai_plugin_manifest = cls(
            api=api,
            auth=auth,
            contact_email=contact_email,
            description_for_human=description_for_human,
            description_for_model=description_for_model,
            legal_info_url=legal_info_url,
            logo_url=logo_url,
            name_for_human=name_for_human,
            name_for_model=name_for_model,
            schema_version=schema_version,
        )

        ai_plugin_manifest.additional_properties = d
        return ai_plugin_manifest

    @property

class AnnotationLineEnd(str, Enum):
    """Annotation line end type"""  # noqa: E501

    ARROW = "arrow"

from ..models.annotation_line_end import AnnotationLineEnd

GO = TypeVar("GO", bound="AnnotationLineEndOptions")

class AnnotationLineEndOptions:
    """Options for annotation text"""  # noqa: E501

    end: Union[Unset, AnnotationLineEnd] = UNSET
    start: Union[Unset, AnnotationLineEnd] = UNSET

        if not isinstance(self.end, Unset):
            end = self.end
        if not isinstance(self.start, Unset):
            start = self.start

        if end is not UNSET:
            field_dict["end"] = end
        if start is not UNSET:
            field_dict["start"] = start

    def from_dict(cls: Type[GO], src_dict: Dict[str, Any]) -> GO:
        _end = d.pop("end", UNSET)
        end: Union[Unset, AnnotationLineEnd]
        if isinstance(_end, Unset):
            end = UNSET
        else:
            end = _end  # type: ignore[arg-type]

        _start = d.pop("start", UNSET)
        start: Union[Unset, AnnotationLineEnd]
        if isinstance(_start, Unset):
            start = UNSET
        else:
            start = _start  # type: ignore[arg-type]

        annotation_line_end_options = cls(
            end=end,
            start=start,
        )

        annotation_line_end_options.additional_properties = d
        return annotation_line_end_options

    @property

from ..models.annotation_line_end_options import AnnotationLineEndOptions
from ..models.annotation_text_options import AnnotationTextOptions
from ..models.color import Color
from ..models.point3d import Point3d

PI = TypeVar("PI", bound="AnnotationOptions")

class AnnotationOptions:
    """Options for annotations"""  # noqa: E501

    color: Union[Unset, Color] = UNSET
    line_ends: Union[Unset, AnnotationLineEndOptions] = UNSET
    line_width: Union[Unset, float] = UNSET
    position: Union[Unset, Point3d] = UNSET
    text: Union[Unset, AnnotationTextOptions] = UNSET

        if not isinstance(self.color, Unset):
            color = self.color
        if not isinstance(self.line_ends, Unset):
            line_ends = self.line_ends
        line_width = self.line_width
        if not isinstance(self.position, Unset):
            position = self.position
        if not isinstance(self.text, Unset):
            text = self.text

        if color is not UNSET:
            field_dict["color"] = color
        if line_ends is not UNSET:
            field_dict["line_ends"] = line_ends
        if line_width is not UNSET:
            field_dict["line_width"] = line_width
        if position is not UNSET:
            field_dict["position"] = position
        if text is not UNSET:
            field_dict["text"] = text

    def from_dict(cls: Type[PI], src_dict: Dict[str, Any]) -> PI:
        _color = d.pop("color", UNSET)
        color: Union[Unset, Color]
        if isinstance(_color, Unset):
            color = UNSET
        else:
            color = _color  # type: ignore[arg-type]

        _line_ends = d.pop("line_ends", UNSET)
        line_ends: Union[Unset, AnnotationLineEndOptions]
        if isinstance(_line_ends, Unset):
            line_ends = UNSET
        else:
            line_ends = _line_ends  # type: ignore[arg-type]

        line_width = d.pop("line_width", UNSET)

        _position = d.pop("position", UNSET)
        position: Union[Unset, Point3d]
        if isinstance(_position, Unset):
            position = UNSET
        else:
            position = _position  # type: ignore[arg-type]

        _text = d.pop("text", UNSET)
        text: Union[Unset, AnnotationTextOptions]
        if isinstance(_text, Unset):
            text = UNSET
        else:
            text = _text  # type: ignore[arg-type]

        annotation_options = cls(
            color=color,
            line_ends=line_ends,
            line_width=line_width,
            position=position,
            text=text,
        )

        annotation_options.additional_properties = d
        return annotation_options

    @property

class AnnotationTextAlignmentX(str, Enum):
    """Horizontal Text aligment"""  # noqa: E501

    LEFT = "left"
    CENTER = "center"
    RIGHT = "right"

class AnnotationTextAlignmentY(str, Enum):
    """Vertical Text aligment"""  # noqa: E501

    BOTTOM = "bottom"
    TOP = "top"

from ..models.annotation_text_alignment_x import AnnotationTextAlignmentX
from ..models.annotation_text_alignment_y import AnnotationTextAlignmentY

UZ = TypeVar("UZ", bound="AnnotationTextOptions")

class AnnotationTextOptions:

    point_size: Union[Unset, int] = UNSET
    text: Union[Unset, str] = UNSET
    x: Union[Unset, AnnotationTextAlignmentX] = UNSET
    y: Union[Unset, AnnotationTextAlignmentY] = UNSET

        point_size = self.point_size
        text = self.text
        if not isinstance(self.x, Unset):
            x = self.x
        if not isinstance(self.y, Unset):
            y = self.y

        if point_size is not UNSET:
            field_dict["point_size"] = point_size
        if x is not UNSET:
            field_dict["x"] = x
        if y is not UNSET:
            field_dict["y"] = y

    def from_dict(cls: Type[UZ], src_dict: Dict[str, Any]) -> UZ:
        point_size = d.pop("point_size", UNSET)

        text = d.pop("text", UNSET)

        _x = d.pop("x", UNSET)
        x: Union[Unset, AnnotationTextAlignmentX]
        if isinstance(_x, Unset):
            x = UNSET
        else:
            x = _x  # type: ignore[arg-type]

        _y = d.pop("y", UNSET)
        y: Union[Unset, AnnotationTextAlignmentY]
        if isinstance(_y, Unset):
            y = UNSET
        else:
            y = _y  # type: ignore[arg-type]

        annotation_text_options = cls(
            point_size=point_size,
            x=x,
            y=y,
        )

        annotation_text_options.additional_properties = d
        return annotation_text_options

    @property

class AnnotationType(str, Enum):
    """The type of annotation"""  # noqa: E501

    """# 2D annotation type (screen or planar space) """  # noqa: E501
    T2D = "t2d"
    """# 3D annotation type """  # noqa: E501
    T3D = "t3d"

FB = TypeVar("FB", bound="ApiCallQueryGroup")

class ApiCallQueryGroup:
    """A response for a query on the API call table that is grouped by something."""  # noqa: E501

    count: Union[Unset, int] = UNSET
    query: Union[Unset, str] = UNSET

        count = self.count
        query = self.query

        if count is not UNSET:
            field_dict["count"] = count
        if query is not UNSET:
            field_dict["query"] = query

    def from_dict(cls: Type[FB], src_dict: Dict[str, Any]) -> FB:
        count = d.pop("count", UNSET)

        query = d.pop("query", UNSET)

        api_call_query_group = cls(
            count=count,
            query=query,
        )

        api_call_query_group.additional_properties = d
        return api_call_query_group

    @property

class ApiCallQueryGroupBy(str, Enum):
    """The field of an API call to group by."""  # noqa: E501

    """# The email of the user that requested the API call. """  # noqa: E501
    EMAIL = "email"
    """# The HTTP method of the API call. """  # noqa: E501
    METHOD = "method"
    """# The endpoint of the API call. """  # noqa: E501
    ENDPOINT = "endpoint"
    """# The user ID of the user that requested the API call. """  # noqa: E501
    USER_ID = "user_id"
    """# The origin of the API call. This is parsed from the `Origin` header. """  # noqa: E501
    ORIGIN = "origin"
    """# The IP address of the user making the API call. """  # noqa: E501
    IP_ADDRESS = "ip_address"

class ApiCallStatus(str, Enum):
    """The status of an async API call."""  # noqa: E501

    """# The async API call is queued. """  # noqa: E501
    QUEUED = "Queued"
    """# The async API call was uploaded to be converted. """  # noqa: E501
    UPLOADED = "Uploaded"
    """# The async API call is in progress. """  # noqa: E501
    IN_PROGRESS = "In Progress"
    """# The async API call has completed. """  # noqa: E501
    COMPLETED = "Completed"
    """# The async API call has failed. """  # noqa: E501
    FAILED = "Failed"

import datetime

from dateutil.parser import isoparse

from ..models.method import Method
from ..models.uuid import Uuid

QP = TypeVar("QP", bound="ApiCallWithPrice")

class ApiCallWithPrice:
    """An API call with the price.

    This is a join of the `ApiCall` and `ApiCallPrice` tables."""  # noqa: E501

    completed_at: Union[Unset, datetime.datetime] = UNSET
    created_at: Union[Unset, datetime.datetime] = UNSET
    duration: Union[Unset, int] = UNSET
    email: Union[Unset, str] = UNSET
    endpoint: Union[Unset, str] = UNSET
    id: Union[Unset, str] = UNSET
    ip_address: Union[Unset, str] = UNSET
    litterbox: Union[Unset, bool] = False
    method: Union[Unset, Method] = UNSET
    minutes: Union[Unset, int] = UNSET
    origin: Union[Unset, str] = UNSET
    price: Union[Unset, float] = UNSET
    request_body: Union[Unset, str] = UNSET
    request_query_params: Union[Unset, str] = UNSET
    response_body: Union[Unset, str] = UNSET
    started_at: Union[Unset, datetime.datetime] = UNSET
    status_code: Union[Unset, int] = UNSET
    stripe_invoice_item_id: Union[Unset, str] = UNSET
    token: Union[Unset, str] = UNSET
    updated_at: Union[Unset, datetime.datetime] = UNSET
    user_agent: Union[Unset, str] = UNSET
    user_id: Union[Unset, str] = UNSET

        completed_at: Union[Unset, str] = UNSET
        if not isinstance(self.completed_at, Unset):
            completed_at = self.completed_at.isoformat()
        created_at: Union[Unset, str] = UNSET
        if not isinstance(self.created_at, Unset):
            created_at = self.created_at.isoformat()
        duration = self.duration
        email = self.email
        endpoint = self.endpoint
        id = self.id
        ip_address = self.ip_address
        litterbox = self.litterbox
        if not isinstance(self.method, Unset):
            method = self.method
        minutes = self.minutes
        origin = self.origin
        price = self.price
        request_body = self.request_body
        request_query_params = self.request_query_params
        response_body = self.response_body
        started_at: Union[Unset, str] = UNSET
        if not isinstance(self.started_at, Unset):
            started_at = self.started_at.isoformat()
        status_code = self.status_code
        stripe_invoice_item_id = self.stripe_invoice_item_id
        token = self.token
        updated_at: Union[Unset, str] = UNSET
        if not isinstance(self.updated_at, Unset):
            updated_at = self.updated_at.isoformat()
        user_agent = self.user_agent
        user_id = self.user_id

        if completed_at is not UNSET:
            field_dict["completed_at"] = completed_at
        if created_at is not UNSET:
            field_dict["created_at"] = created_at
        if duration is not UNSET:
            field_dict["duration"] = duration
        if email is not UNSET:
            field_dict["email"] = email
        if endpoint is not UNSET:
            field_dict["endpoint"] = endpoint
        if id is not UNSET:
            field_dict["id"] = id
        if ip_address is not UNSET:
            field_dict["ip_address"] = ip_address
        if litterbox is not UNSET:
            field_dict["litterbox"] = litterbox
        if method is not UNSET:
            field_dict["method"] = method
        if minutes is not UNSET:
            field_dict["minutes"] = minutes
        if origin is not UNSET:
            field_dict["origin"] = origin
        if price is not UNSET:
            field_dict["price"] = price
        if request_body is not UNSET:
            field_dict["request_body"] = request_body
        if request_query_params is not UNSET:
            field_dict["request_query_params"] = request_query_params
        if response_body is not UNSET:
            field_dict["response_body"] = response_body
        if started_at is not UNSET:
            field_dict["started_at"] = started_at
        if status_code is not UNSET:
            field_dict["status_code"] = status_code
        if stripe_invoice_item_id is not UNSET:
            field_dict["stripe_invoice_item_id"] = stripe_invoice_item_id
        if token is not UNSET:
            field_dict["token"] = token
        if updated_at is not UNSET:
            field_dict["updated_at"] = updated_at
        if user_agent is not UNSET:
            field_dict["user_agent"] = user_agent
        if user_id is not UNSET:
            field_dict["user_id"] = user_id

    def from_dict(cls: Type[QP], src_dict: Dict[str, Any]) -> QP:
        _completed_at = d.pop("completed_at", UNSET)
        completed_at: Union[Unset, datetime.datetime]
        if isinstance(_completed_at, Unset):
            completed_at = UNSET
        else:
            completed_at = isoparse(_completed_at)

        _created_at = d.pop("created_at", UNSET)
        created_at: Union[Unset, datetime.datetime]
        if isinstance(_created_at, Unset):
            created_at = UNSET
        else:
            created_at = isoparse(_created_at)

        duration = d.pop("duration", UNSET)

        email = d.pop("email", UNSET)

        endpoint = d.pop("endpoint", UNSET)

        _id = d.pop("id", UNSET)
        id: Union[Unset, Uuid]
        if isinstance(_id, Unset):
            id = UNSET
        else:
            id = _id  # type: ignore[arg-type]

        ip_address = d.pop("ip_address", UNSET)

        litterbox = d.pop("litterbox", UNSET)

        _method = d.pop("method", UNSET)
        method: Union[Unset, Method]
        if isinstance(_method, Unset):
            method = UNSET
        else:
            method = _method  # type: ignore[arg-type]

        minutes = d.pop("minutes", UNSET)

        origin = d.pop("origin", UNSET)

        price = d.pop("price", UNSET)

        request_body = d.pop("request_body", UNSET)

        request_query_params = d.pop("request_query_params", UNSET)

        response_body = d.pop("response_body", UNSET)

        _started_at = d.pop("started_at", UNSET)
        started_at: Union[Unset, datetime.datetime]
        if isinstance(_started_at, Unset):
            started_at = UNSET
        else:
            started_at = isoparse(_started_at)

        status_code = d.pop("status_code", UNSET)

        stripe_invoice_item_id = d.pop("stripe_invoice_item_id", UNSET)

        _token = d.pop("token", UNSET)
        token: Union[Unset, Uuid]
        if isinstance(_token, Unset):
            token = UNSET
        else:
            token = _token  # type: ignore[arg-type]

        _updated_at = d.pop("updated_at", UNSET)
        updated_at: Union[Unset, datetime.datetime]
        if isinstance(_updated_at, Unset):
            updated_at = UNSET
        else:
            updated_at = isoparse(_updated_at)

        user_agent = d.pop("user_agent", UNSET)

        user_id = d.pop("user_id", UNSET)

        api_call_with_price = cls(
            completed_at=completed_at,
            created_at=created_at,
            duration=duration,
            endpoint=endpoint,
            id=id,
            ip_address=ip_address,
            litterbox=litterbox,
            method=method,
            minutes=minutes,
            origin=origin,
            price=price,
            request_body=request_body,
            request_query_params=request_query_params,
            response_body=response_body,
            started_at=started_at,
            status_code=status_code,
            stripe_invoice_item_id=stripe_invoice_item_id,
            updated_at=updated_at,
            user_agent=user_agent,
            user_id=user_id,
        )

        api_call_with_price.additional_properties = d
        return api_call_with_price

    @property

from typing import Any, Dict, List, Type, TypeVar, Union, cast

KC = TypeVar("KC", bound="ApiCallWithPriceResultsPage")

class ApiCallWithPriceResultsPage:
    """A single page of results"""  # noqa: E501

    from ..models.api_call_with_price import ApiCallWithPrice

    items: Union[Unset, List[ApiCallWithPrice]] = UNSET
    next_page: Union[Unset, str] = UNSET

        from ..models.api_call_with_price import ApiCallWithPrice

        items: Union[Unset, List[ApiCallWithPrice]] = UNSET
        if not isinstance(self.items, Unset):
            items = self.items
        next_page = self.next_page

        if items is not UNSET:
            field_dict["items"] = items
        if next_page is not UNSET:
            field_dict["next_page"] = next_page

    def from_dict(cls: Type[KC], src_dict: Dict[str, Any]) -> KC:

        items = cast(List[ApiCallWithPrice], d.pop("items", UNSET))

        next_page = d.pop("next_page", UNSET)

        api_call_with_price_results_page = cls(
            items=items,
            next_page=next_page,
        )

        api_call_with_price_results_page.additional_properties = d
        return api_call_with_price_results_page

    @property

HX = TypeVar("HX", bound="ApiToken")

class ApiToken:
    """An API token.

    These are used to authenticate users with Bearer authentication."""  # noqa: E501

    is_valid: Union[Unset, bool] = False

        is_valid = self.is_valid

        if is_valid is not UNSET:
            field_dict["is_valid"] = is_valid

    def from_dict(cls: Type[HX], src_dict: Dict[str, Any]) -> HX:
        else:

        id = d.pop("id", UNSET)

        is_valid = d.pop("is_valid", UNSET)

        else:

        else:

        api_token = cls(
            id=id,
            is_valid=is_valid,
        )

        api_token.additional_properties = d
        return api_token

    @property

LB = TypeVar("LB", bound="ApiTokenResultsPage")

class ApiTokenResultsPage:

    from ..models.api_token import ApiToken

    items: Union[Unset, List[ApiToken]] = UNSET

        from ..models.api_token import ApiToken

        items: Union[Unset, List[ApiToken]] = UNSET

    def from_dict(cls: Type[LB], src_dict: Dict[str, Any]) -> LB:

        items = cast(List[ApiToken], d.pop("items", UNSET))

        api_token_results_page = cls(
        )

        api_token_results_page.additional_properties = d
        return api_token_results_page

    @property

NE = TypeVar("NE", bound="AppClientInfo")

class AppClientInfo:
    """Information about a third party app client."""  # noqa: E501

    def from_dict(cls: Type[NE], src_dict: Dict[str, Any]) -> NE:

        app_client_info = cls(
            url=url,
        )

        app_client_info.additional_properties = d
        return app_client_info

    @property

from ..models.api_call_status import ApiCallStatus
from ..models.async_api_call_type import AsyncApiCallType

TL = TypeVar("TL", bound="AsyncApiCall")

class AsyncApiCall:
    """An async API call."""  # noqa: E501

    error: Union[Unset, str] = UNSET
    input: Union[Unset, Any] = UNSET
    output: Union[Unset, Any] = UNSET
    status: Union[Unset, ApiCallStatus] = UNSET
    type: Union[Unset, AsyncApiCallType] = UNSET
    worker: Union[Unset, str] = UNSET

        error = self.error
        input = self.input
        output = self.output
        if not isinstance(self.status, Unset):
            status = self.status
        worker = self.worker

        if error is not UNSET:
            field_dict["error"] = error
        if input is not UNSET:
            field_dict["input"] = input
        if output is not UNSET:
            field_dict["output"] = output
        if status is not UNSET:
            field_dict["status"] = status
        if worker is not UNSET:
            field_dict["worker"] = worker

    def from_dict(cls: Type[TL], src_dict: Dict[str, Any]) -> TL:
        else:

        else:

        error = d.pop("error", UNSET)

            id = UNSET
        else:

        input = d.pop("input", UNSET)
        output = d.pop("output", UNSET)
        else:

        _status = d.pop("status", UNSET)
        status: Union[Unset, ApiCallStatus]
        if isinstance(_status, Unset):
            status = UNSET
        else:
            status = _status  # type: ignore[arg-type]

        type: Union[Unset, AsyncApiCallType]
        else:

        else:

        worker = d.pop("worker", UNSET)

        async_api_call = cls(
            error=error,
            id=id,
            input=input,
            worker=worker,
        )

        async_api_call.additional_properties = d
        return async_api_call

    @property

from ..models.file_export_format import FileExportFormat
from ..models.file_import_format import FileImportFormat
from ..models.input_format import InputFormat
from ..models.output_format import OutputFormat
from ..models.unit_area import UnitArea
from ..models.unit_density import UnitDensity
from ..models.unit_length import UnitLength
from ..models.unit_mass import UnitMass
from ..models.unit_volume import UnitVolume

MN = TypeVar("MN", bound="FileConversion")

class FileConversion:
    """A file conversion."""  # noqa: E501

    output: Union[Unset, str] = UNSET
    output_format: Union[Unset, FileExportFormat] = UNSET
    output_format_options: Union[Unset, OutputFormat] = UNSET
    outputs: Union[Unset, Any] = UNSET
    src_format: Union[Unset, FileImportFormat] = UNSET
    src_format_options: Union[Unset, InputFormat] = UNSET
    type: str = "FileConversion"

        if not isinstance(self.output_format, Unset):
            output_format = self.output_format
        if not isinstance(self.output_format_options, Unset):
            output_format_options = self.output_format_options
        outputs = self.outputs
        if not isinstance(self.src_format, Unset):
            src_format = self.src_format
        if not isinstance(self.src_format_options, Unset):
            src_format_options = self.src_format_options
        type = self.type

        if output_format is not UNSET:
            field_dict["output_format"] = output_format
        if output_format_options is not UNSET:
            field_dict["output_format_options"] = output_format_options
        if outputs is not UNSET:
            field_dict["outputs"] = outputs
        if src_format is not UNSET:
            field_dict["src_format"] = src_format
        if src_format_options is not UNSET:
            field_dict["src_format_options"] = src_format_options
        field_dict["type"] = type

    def from_dict(cls: Type[MN], src_dict: Dict[str, Any]) -> MN:
        else:

        else:

            id = UNSET
        else:

        _output_format = d.pop("output_format", UNSET)
        output_format: Union[Unset, FileExportFormat]
        if isinstance(_output_format, Unset):
            output_format = UNSET
        else:
            output_format = _output_format  # type: ignore[arg-type]

        _output_format_options = d.pop("output_format_options", UNSET)
        output_format_options: Union[Unset, OutputFormat]
        if isinstance(_output_format_options, Unset):
            output_format_options = UNSET
        else:
            output_format_options = _output_format_options  # type: ignore[arg-type]

        outputs = d.pop("outputs", UNSET)
        _src_format = d.pop("src_format", UNSET)
        src_format: Union[Unset, FileImportFormat]
        if isinstance(_src_format, Unset):
            src_format = UNSET
        else:
            src_format = _src_format  # type: ignore[arg-type]

        _src_format_options = d.pop("src_format_options", UNSET)
        src_format_options: Union[Unset, InputFormat]
        if isinstance(_src_format_options, Unset):
            src_format_options = UNSET
        else:
            src_format_options = _src_format_options  # type: ignore[arg-type]

        else:

        else:

        type = d.pop("type", UNSET)

        else:

        file_conversion = cls(
            id=id,
            output_format_options=output_format_options,
            outputs=outputs,
            src_format_options=src_format_options,
        )

        file_conversion.additional_properties = d
        return file_conversion

    @property

JV = TypeVar("JV", bound="FileCenterOfMass")

class FileCenterOfMass:
    """File center of mass."""  # noqa: E501

    center_of_mass: Union[Unset, Point3d] = UNSET
    output_unit: Union[Unset, UnitLength] = UNSET
    type: str = "FileCenterOfMass"

        if not isinstance(self.center_of_mass, Unset):
            center_of_mass = self.center_of_mass
        if not isinstance(self.output_unit, Unset):
            output_unit = self.output_unit

        if center_of_mass is not UNSET:
            field_dict["center_of_mass"] = center_of_mass
        if output_unit is not UNSET:
            field_dict["output_unit"] = output_unit

    def from_dict(cls: Type[JV], src_dict: Dict[str, Any]) -> JV:
        _center_of_mass = d.pop("center_of_mass", UNSET)
        center_of_mass: Union[Unset, Point3d]
        if isinstance(_center_of_mass, Unset):
            center_of_mass = UNSET
        else:
            center_of_mass = _center_of_mass  # type: ignore[arg-type]

        else:

        else:

            id = UNSET
        else:

        _output_unit = d.pop("output_unit", UNSET)
        output_unit: Union[Unset, UnitLength]
        if isinstance(_output_unit, Unset):
            output_unit = UNSET
        else:
            output_unit = _output_unit  # type: ignore[arg-type]

        else:

        else:

        else:

        else:

        file_center_of_mass = cls(
            center_of_mass=center_of_mass,
            id=id,
        )

        file_center_of_mass.additional_properties = d
        return file_center_of_mass

    @property

IO = TypeVar("IO", bound="FileMass")

class FileMass:
    """A file mass."""  # noqa: E501

    mass: Union[Unset, float] = UNSET
    material_density: Union[Unset, float] = UNSET
    material_density_unit: Union[Unset, UnitDensity] = UNSET
    output_unit: Union[Unset, UnitMass] = UNSET
    type: str = "FileMass"

        mass = self.mass
        material_density = self.material_density
        if not isinstance(self.material_density_unit, Unset):
            material_density_unit = self.material_density_unit

        if mass is not UNSET:
            field_dict["mass"] = mass
        if material_density is not UNSET:
            field_dict["material_density"] = material_density
        if material_density_unit is not UNSET:
            field_dict["material_density_unit"] = material_density_unit

    def from_dict(cls: Type[IO], src_dict: Dict[str, Any]) -> IO:
        else:

        else:

            id = UNSET
        else:

        mass = d.pop("mass", UNSET)

        material_density = d.pop("material_density", UNSET)

        _material_density_unit = d.pop("material_density_unit", UNSET)
        material_density_unit: Union[Unset, UnitDensity]
        if isinstance(_material_density_unit, Unset):
            material_density_unit = UNSET
        else:
            material_density_unit = _material_density_unit  # type: ignore[arg-type]

        output_unit: Union[Unset, UnitMass]
        else:

        else:

        else:

        else:

        else:

        file_mass = cls(
            id=id,
            mass=mass,
        )

        file_mass.additional_properties = d
        return file_mass

    @property

FV = TypeVar("FV", bound="FileVolume")

class FileVolume:
    """A file volume."""  # noqa: E501

    output_unit: Union[Unset, UnitVolume] = UNSET
    type: str = "FileVolume"
    volume: Union[Unset, float] = UNSET

        volume = self.volume

        if volume is not UNSET:
            field_dict["volume"] = volume

    def from_dict(cls: Type[FV], src_dict: Dict[str, Any]) -> FV:
        else:

        else:

            id = UNSET
        else:

        output_unit: Union[Unset, UnitVolume]
        else:

        else:

        else:

        else:

        else:

        volume = d.pop("volume", UNSET)

        file_volume = cls(
            id=id,
            volume=volume,
        )

        file_volume.additional_properties = d
        return file_volume

    @property

LE = TypeVar("LE", bound="FileDensity")

class FileDensity:
    """A file density."""  # noqa: E501

    density: Union[Unset, float] = UNSET
    material_mass: Union[Unset, float] = UNSET
    material_mass_unit: Union[Unset, UnitMass] = UNSET
    output_unit: Union[Unset, UnitDensity] = UNSET
    type: str = "FileDensity"

        density = self.density
        material_mass = self.material_mass
        if not isinstance(self.material_mass_unit, Unset):
            material_mass_unit = self.material_mass_unit

        if density is not UNSET:
            field_dict["density"] = density
        if material_mass is not UNSET:
            field_dict["material_mass"] = material_mass
        if material_mass_unit is not UNSET:
            field_dict["material_mass_unit"] = material_mass_unit

    def from_dict(cls: Type[LE], src_dict: Dict[str, Any]) -> LE:
        else:

        else:

        density = d.pop("density", UNSET)

            id = UNSET
        else:

        material_mass = d.pop("material_mass", UNSET)

        _material_mass_unit = d.pop("material_mass_unit", UNSET)
        material_mass_unit: Union[Unset, UnitMass]
        if isinstance(_material_mass_unit, Unset):
            material_mass_unit = UNSET
        else:
            material_mass_unit = _material_mass_unit  # type: ignore[arg-type]

        output_unit: Union[Unset, UnitDensity]
        else:

        else:

        else:

        else:

        else:

        file_density = cls(
            density=density,
            id=id,
        )

        file_density.additional_properties = d
        return file_density

    @property

OY = TypeVar("OY", bound="FileSurfaceArea")

class FileSurfaceArea:
    """A file surface area."""  # noqa: E501

    output_unit: Union[Unset, UnitArea] = UNSET
    surface_area: Union[Unset, float] = UNSET
    type: str = "FileSurfaceArea"

        surface_area = self.surface_area

        if surface_area is not UNSET:
            field_dict["surface_area"] = surface_area

    def from_dict(cls: Type[OY], src_dict: Dict[str, Any]) -> OY:
        else:

        else:

            id = UNSET
        else:

        output_unit: Union[Unset, UnitArea]
        else:

        else:

        else:

        else:

        surface_area = d.pop("surface_area", UNSET)

        else:

        file_surface_area = cls(
            id=id,
            surface_area=surface_area,
        )

        file_surface_area.additional_properties = d
        return file_surface_area

    @property

AsyncApiCallOutput = Union[
    FileConversion, FileCenterOfMass, FileMass, FileVolume, FileDensity, FileSurfaceArea
]

HO = TypeVar("HO", bound="AsyncApiCallResultsPage")

class AsyncApiCallResultsPage:

    from ..models.async_api_call import AsyncApiCall

    items: Union[Unset, List[AsyncApiCall]] = UNSET

        from ..models.async_api_call import AsyncApiCall

        items: Union[Unset, List[AsyncApiCall]] = UNSET

    def from_dict(cls: Type[HO], src_dict: Dict[str, Any]) -> HO:

        items = cast(List[AsyncApiCall], d.pop("items", UNSET))

        async_api_call_results_page = cls(
        )

        async_api_call_results_page.additional_properties = d
        return async_api_call_results_page

    @property

class AsyncApiCallType(str, Enum):
    """The type of async API call."""  # noqa: E501

    """# File conversion. """  # noqa: E501
    FILE_CONVERSION = "FileConversion"
    """# File volume. """  # noqa: E501
    FILE_VOLUME = "FileVolume"
    """# File center of mass. """  # noqa: E501
    FILE_CENTER_OF_MASS = "FileCenterOfMass"
    """# File mass. """  # noqa: E501
    FILE_MASS = "FileMass"
    """# File density. """  # noqa: E501
    FILE_DENSITY = "FileDensity"
    """# File surface area. """  # noqa: E501
    FILE_SURFACE_AREA = "FileSurfaceArea"

class Axis(str, Enum):
    """Co-ordinate axis specifier.

    See [cglearn.eu] for background reading.

    [cglearn.eu]: https://cglearn.eu/pub/computer-graphics/introduction-to-geometry#material-coordinate-systems-1

    """# 'Y' axis. """  # noqa: E501
    Y = "y"
    """# 'Z' axis. """  # noqa: E501
    Z = "z"

from ..models.axis import Axis
from ..models.direction import Direction

TM = TypeVar("TM", bound="AxisDirectionPair")

class AxisDirectionPair:
    """An [`Axis`] paired with a [`Direction`]."""  # noqa: E501

    axis: Union[Unset, Axis] = UNSET
    direction: Union[Unset, Direction] = UNSET

        if not isinstance(self.axis, Unset):
            axis = self.axis
        if not isinstance(self.direction, Unset):
            direction = self.direction

        if axis is not UNSET:
            field_dict["axis"] = axis
        if direction is not UNSET:
            field_dict["direction"] = direction

    def from_dict(cls: Type[TM], src_dict: Dict[str, Any]) -> TM:
        _axis = d.pop("axis", UNSET)
        axis: Union[Unset, Axis]
        if isinstance(_axis, Unset):
            axis = UNSET
        else:
            axis = _axis  # type: ignore[arg-type]

        _direction = d.pop("direction", UNSET)
        direction: Union[Unset, Direction]
        if isinstance(_direction, Unset):
            direction = UNSET
        else:
            direction = _direction  # type: ignore[arg-type]

        axis_direction_pair = cls(
            axis=axis,
            direction=direction,
        )

        axis_direction_pair.additional_properties = d
        return axis_direction_pair

    @property

from ..models.new_address import NewAddress

BS = TypeVar("BS", bound="BillingInfo")

class BillingInfo:
    """The billing information for payments."""  # noqa: E501

    address: Union[Unset, NewAddress] = UNSET
    name: Union[Unset, str] = UNSET
    phone: Union[Unset, str] = UNSET

        if not isinstance(self.address, Unset):
            address = self.address
        name = self.name
        phone = self.phone

        if address is not UNSET:
            field_dict["address"] = address
        if name is not UNSET:
            field_dict["name"] = name
        if phone is not UNSET:
            field_dict["phone"] = phone

    def from_dict(cls: Type[BS], src_dict: Dict[str, Any]) -> BS:
        _address = d.pop("address", UNSET)
        address: Union[Unset, NewAddress]
        if isinstance(_address, Unset):
            address = UNSET
        else:
            address = _address  # type: ignore[arg-type]

        name = d.pop("name", UNSET)

        phone = d.pop("phone", UNSET)

        billing_info = cls(
            address=address,
            name=name,
            phone=phone,
        )

        billing_info.additional_properties = d
        return billing_info

    @property

AH = TypeVar("AH", bound="CacheMetadata")

class CacheMetadata:
    """Metadata about our cache.

    This is mostly used for internal purposes and debugging."""  # noqa: E501

    ok: Union[Unset, bool] = False

        ok = self.ok

        if ok is not UNSET:
            field_dict["ok"] = ok

    def from_dict(cls: Type[AH], src_dict: Dict[str, Any]) -> AH:
        ok = d.pop("ok", UNSET)

        cache_metadata = cls(
            ok=ok,
        )

        cache_metadata.additional_properties = d
        return cache_metadata

    @property

class CameraDragInteractionType(str, Enum):
    """The type of camera drag interaction."""  # noqa: E501

    """# Camera pan """  # noqa: E501
    PAN = "pan"
    """# Camera rotate (revolve/orbit) """  # noqa: E501
    ROTATE = "rotate"
    """# Camera zoom (increase or decrease distance to reference point center) """  # noqa: E501
    ZOOM = "zoom"

from ..models.payment_method_card_checks import PaymentMethodCardChecks

EG = TypeVar("EG", bound="CardDetails")

class CardDetails:
    """The card details of a payment method."""  # noqa: E501

    brand: Union[Unset, str] = UNSET
    checks: Union[Unset, PaymentMethodCardChecks] = UNSET
    country: Union[Unset, str] = UNSET
    exp_month: Union[Unset, int] = UNSET
    exp_year: Union[Unset, int] = UNSET
    fingerprint: Union[Unset, str] = UNSET
    funding: Union[Unset, str] = UNSET
    last4: Union[Unset, str] = UNSET

        brand = self.brand
        if not isinstance(self.checks, Unset):
            checks = self.checks
        country = self.country
        exp_month = self.exp_month
        exp_year = self.exp_year
        fingerprint = self.fingerprint
        funding = self.funding
        last4 = self.last4

        if brand is not UNSET:
            field_dict["brand"] = brand
        if checks is not UNSET:
            field_dict["checks"] = checks
        if country is not UNSET:
            field_dict["country"] = country
        if exp_month is not UNSET:
            field_dict["exp_month"] = exp_month
        if exp_year is not UNSET:
            field_dict["exp_year"] = exp_year
        if fingerprint is not UNSET:
            field_dict["fingerprint"] = fingerprint
        if funding is not UNSET:
            field_dict["funding"] = funding
        if last4 is not UNSET:
            field_dict["last4"] = last4

    def from_dict(cls: Type[EG], src_dict: Dict[str, Any]) -> EG:
        brand = d.pop("brand", UNSET)

        _checks = d.pop("checks", UNSET)
        checks: Union[Unset, PaymentMethodCardChecks]
        if isinstance(_checks, Unset):
            checks = UNSET
        else:
            checks = _checks  # type: ignore[arg-type]

        country = d.pop("country", UNSET)

        exp_month = d.pop("exp_month", UNSET)

        exp_year = d.pop("exp_year", UNSET)

        fingerprint = d.pop("fingerprint", UNSET)

        funding = d.pop("funding", UNSET)

        last4 = d.pop("last4", UNSET)

        card_details = cls(
            brand=brand,
            checks=checks,
            country=country,
            exp_month=exp_month,
            exp_year=exp_year,
            fingerprint=fingerprint,
            funding=funding,
            last4=last4,
        )

        card_details.additional_properties = d
        return card_details

    @property

JR = TypeVar("JR", bound="Cluster")

class Cluster:
    """Cluster information."""  # noqa: E501

    addr: Union[Unset, str] = UNSET
    auth_timeout: Union[Unset, int] = UNSET
    cluster_port: Union[Unset, int] = UNSET
    tls_timeout: Union[Unset, int] = UNSET
    urls: Union[Unset, List[str]] = UNSET

        addr = self.addr
        auth_timeout = self.auth_timeout
        cluster_port = self.cluster_port
        tls_timeout = self.tls_timeout
        urls: Union[Unset, List[str]] = UNSET
        if not isinstance(self.urls, Unset):
            urls = self.urls

        if addr is not UNSET:
            field_dict["addr"] = addr
        if auth_timeout is not UNSET:
            field_dict["auth_timeout"] = auth_timeout
        if cluster_port is not UNSET:
            field_dict["cluster_port"] = cluster_port
        if tls_timeout is not UNSET:
            field_dict["tls_timeout"] = tls_timeout
        if urls is not UNSET:
            field_dict["urls"] = urls

    def from_dict(cls: Type[JR], src_dict: Dict[str, Any]) -> JR:
        addr = d.pop("addr", UNSET)

        auth_timeout = d.pop("auth_timeout", UNSET)

        cluster_port = d.pop("cluster_port", UNSET)

        tls_timeout = d.pop("tls_timeout", UNSET)

        urls = cast(List[str], d.pop("urls", UNSET))

        cluster = cls(
            addr=addr,
            auth_timeout=auth_timeout,
            cluster_port=cluster_port,
            tls_timeout=tls_timeout,
            urls=urls,
        )

        cluster.additional_properties = d
        return cluster

    @property

class CodeLanguage(str, Enum):
    """The language code is written in."""  # noqa: E501

    """# The `go` programming language. """  # noqa: E501
    GO = "go"
    """# The `python` programming language. """  # noqa: E501
    PYTHON = "python"
    """# The `node` programming language. """  # noqa: E501
    NODE = "node"

LY = TypeVar("LY", bound="CodeOutput")

class CodeOutput:
    """Output of the code being executed."""  # noqa: E501

    from ..models.output_file import OutputFile

    output_files: Union[Unset, List[OutputFile]] = UNSET
    stderr: Union[Unset, str] = UNSET
    stdout: Union[Unset, str] = UNSET

        from ..models.output_file import OutputFile

        output_files: Union[Unset, List[OutputFile]] = UNSET
        if not isinstance(self.output_files, Unset):
            output_files = self.output_files
        stderr = self.stderr
        stdout = self.stdout

        if output_files is not UNSET:
            field_dict["output_files"] = output_files
        if stderr is not UNSET:
            field_dict["stderr"] = stderr
        if stdout is not UNSET:
            field_dict["stdout"] = stdout

    def from_dict(cls: Type[LY], src_dict: Dict[str, Any]) -> LY:

        output_files = cast(List[OutputFile], d.pop("output_files", UNSET))

        stderr = d.pop("stderr", UNSET)

        stdout = d.pop("stdout", UNSET)

        code_output = cls(
            output_files=output_files,
            stderr=stderr,
            stdout=stdout,
        )

        code_output.additional_properties = d
        return code_output

    @property

HK = TypeVar("HK", bound="Color")

class Color:
    """An RGBA color"""  # noqa: E501

    a: Union[Unset, float] = UNSET
    b: Union[Unset, float] = UNSET
    g: Union[Unset, float] = UNSET
    r: Union[Unset, float] = UNSET

        a = self.a
        b = self.b
        g = self.g
        r = self.r

        if a is not UNSET:
            field_dict["a"] = a
        if b is not UNSET:
            field_dict["b"] = b
        if g is not UNSET:
            field_dict["g"] = g
        if r is not UNSET:
            field_dict["r"] = r

    def from_dict(cls: Type[HK], src_dict: Dict[str, Any]) -> HK:
        a = d.pop("a", UNSET)

        b = d.pop("b", UNSET)

        g = d.pop("g", UNSET)

        r = d.pop("r", UNSET)

        color = cls(
            a=a,
            b=b,
            g=g,
            r=r,
        )

        color.additional_properties = d
        return color

    @property

VR = TypeVar("VR", bound="Commit")

class Commit:
    """Commit holds the Git-commit (SHA1) that a binary was built from, as reported in the version-string of external tools, such as `containerd`, or `runC`."""  # noqa: E501

    expected: Union[Unset, str] = UNSET

        expected = self.expected

        if expected is not UNSET:
            field_dict["expected"] = expected

    def from_dict(cls: Type[VR], src_dict: Dict[str, Any]) -> VR:
        expected = d.pop("expected", UNSET)

        commit = cls(
            expected=expected,
            id=id,
        )

        commit.additional_properties = d
        return commit

    @property

from ..models.cluster import Cluster
from ..models.gateway import Gateway
from ..models.jetstream import Jetstream
from ..models.leaf_node import LeafNode

ON = TypeVar("ON", bound="Connection")

class Connection:
    """Metadata about a pub-sub connection.

    cluster: Union[Unset, Cluster] = UNSET
    config_load_time: Union[Unset, datetime.datetime] = UNSET
    connections: Union[Unset, int] = UNSET
    cores: Union[Unset, int] = UNSET
    cpu: Union[Unset, float] = UNSET
    gateway: Union[Unset, Gateway] = UNSET
    git_commit: Union[Unset, str] = UNSET
    go: Union[Unset, str] = UNSET
    gomaxprocs: Union[Unset, int] = UNSET
    host: Union[Unset, str] = UNSET
    http_base_path: Union[Unset, str] = UNSET
    http_host: Union[Unset, str] = UNSET
    http_port: Union[Unset, int] = UNSET
    http_req_stats: Union[Unset, Any] = UNSET
    https_port: Union[Unset, int] = UNSET
    in_bytes: Union[Unset, int] = UNSET
    in_msgs: Union[Unset, int] = UNSET
    jetstream: Union[Unset, Jetstream] = UNSET
    leaf: Union[Unset, LeafNode] = UNSET
    leafnodes: Union[Unset, int] = UNSET
    max_connections: Union[Unset, int] = UNSET
    max_control_line: Union[Unset, int] = UNSET
    max_payload: Union[Unset, int] = UNSET
    max_pending: Union[Unset, int] = UNSET
    mem: Union[Unset, int] = UNSET
    now: Union[Unset, datetime.datetime] = UNSET
    out_bytes: Union[Unset, int] = UNSET
    out_msgs: Union[Unset, int] = UNSET
    ping_interval: Union[Unset, int] = UNSET
    ping_max: Union[Unset, int] = UNSET
    port: Union[Unset, int] = UNSET
    proto: Union[Unset, int] = UNSET
    remotes: Union[Unset, int] = UNSET
    routes: Union[Unset, int] = UNSET
    server_id: Union[Unset, str] = UNSET
    server_name: Union[Unset, str] = UNSET
    slow_consumers: Union[Unset, int] = UNSET
    start: Union[Unset, datetime.datetime] = UNSET
    subscriptions: Union[Unset, int] = UNSET
    system_account: Union[Unset, str] = UNSET
    total_connections: Union[Unset, int] = UNSET
    uptime: Union[Unset, str] = UNSET
    version: Union[Unset, str] = UNSET
    write_deadline: Union[Unset, int] = UNSET

        if not isinstance(self.cluster, Unset):
            cluster = self.cluster
        config_load_time: Union[Unset, str] = UNSET
        if not isinstance(self.config_load_time, Unset):
            config_load_time = self.config_load_time.isoformat()
        connections = self.connections
        cores = self.cores
        cpu = self.cpu
        if not isinstance(self.gateway, Unset):
            gateway = self.gateway
        git_commit = self.git_commit
        go = self.go
        gomaxprocs = self.gomaxprocs
        host = self.host
        http_base_path = self.http_base_path
        http_host = self.http_host
        http_port = self.http_port
        http_req_stats = self.http_req_stats
        https_port = self.https_port
        in_bytes = self.in_bytes
        in_msgs = self.in_msgs
        if not isinstance(self.jetstream, Unset):
            jetstream = self.jetstream
        if not isinstance(self.leaf, Unset):
            leaf = self.leaf
        leafnodes = self.leafnodes
        max_connections = self.max_connections
        max_control_line = self.max_control_line
        max_payload = self.max_payload
        max_pending = self.max_pending
        mem = self.mem
        now: Union[Unset, str] = UNSET
        if not isinstance(self.now, Unset):
            now = self.now.isoformat()
        out_bytes = self.out_bytes
        out_msgs = self.out_msgs
        ping_interval = self.ping_interval
        ping_max = self.ping_max
        port = self.port
        proto = self.proto
        remotes = self.remotes
        routes = self.routes
        server_id = self.server_id
        server_name = self.server_name
        slow_consumers = self.slow_consumers
        start: Union[Unset, str] = UNSET
            start = self.start.isoformat()
        subscriptions = self.subscriptions
        system_account = self.system_account
        total_connections = self.total_connections
        uptime = self.uptime
        version = self.version
        write_deadline = self.write_deadline

        if cluster is not UNSET:
            field_dict["cluster"] = cluster
        if config_load_time is not UNSET:
            field_dict["config_load_time"] = config_load_time
        if connections is not UNSET:
            field_dict["connections"] = connections
        if cores is not UNSET:
            field_dict["cores"] = cores
        if cpu is not UNSET:
            field_dict["cpu"] = cpu
        if gateway is not UNSET:
            field_dict["gateway"] = gateway
        if git_commit is not UNSET:
            field_dict["git_commit"] = git_commit
        if go is not UNSET:
            field_dict["go"] = go
        if gomaxprocs is not UNSET:
            field_dict["gomaxprocs"] = gomaxprocs
        if host is not UNSET:
            field_dict["host"] = host
        if http_base_path is not UNSET:
            field_dict["http_base_path"] = http_base_path
        if http_host is not UNSET:
            field_dict["http_host"] = http_host
        if http_port is not UNSET:
            field_dict["http_port"] = http_port
        if http_req_stats is not UNSET:
            field_dict["http_req_stats"] = http_req_stats
        if https_port is not UNSET:
            field_dict["https_port"] = https_port
        if in_bytes is not UNSET:
            field_dict["in_bytes"] = in_bytes
        if in_msgs is not UNSET:
            field_dict["in_msgs"] = in_msgs
        if jetstream is not UNSET:
            field_dict["jetstream"] = jetstream
        if leaf is not UNSET:
            field_dict["leaf"] = leaf
        if leafnodes is not UNSET:
            field_dict["leafnodes"] = leafnodes
        if max_connections is not UNSET:
            field_dict["max_connections"] = max_connections
        if max_control_line is not UNSET:
            field_dict["max_control_line"] = max_control_line
        if max_payload is not UNSET:
            field_dict["max_payload"] = max_payload
        if max_pending is not UNSET:
            field_dict["max_pending"] = max_pending
        if mem is not UNSET:
            field_dict["mem"] = mem
        if now is not UNSET:
            field_dict["now"] = now
        if out_bytes is not UNSET:
            field_dict["out_bytes"] = out_bytes
        if out_msgs is not UNSET:
            field_dict["out_msgs"] = out_msgs
        if ping_interval is not UNSET:
            field_dict["ping_interval"] = ping_interval
        if ping_max is not UNSET:
            field_dict["ping_max"] = ping_max
        if port is not UNSET:
            field_dict["port"] = port
        if proto is not UNSET:
            field_dict["proto"] = proto
        if remotes is not UNSET:
            field_dict["remotes"] = remotes
        if routes is not UNSET:
            field_dict["routes"] = routes
        if server_id is not UNSET:
            field_dict["server_id"] = server_id
        if server_name is not UNSET:
            field_dict["server_name"] = server_name
        if slow_consumers is not UNSET:
            field_dict["slow_consumers"] = slow_consumers
        if subscriptions is not UNSET:
            field_dict["subscriptions"] = subscriptions
        if system_account is not UNSET:
            field_dict["system_account"] = system_account
        if total_connections is not UNSET:
            field_dict["total_connections"] = total_connections
        if uptime is not UNSET:
            field_dict["uptime"] = uptime
        if version is not UNSET:
            field_dict["version"] = version
        if write_deadline is not UNSET:
            field_dict["write_deadline"] = write_deadline

    def from_dict(cls: Type[ON], src_dict: Dict[str, Any]) -> ON:

        _cluster = d.pop("cluster", UNSET)
        cluster: Union[Unset, Cluster]
        if isinstance(_cluster, Unset):
            cluster = UNSET
        else:
            cluster = _cluster  # type: ignore[arg-type]

        _config_load_time = d.pop("config_load_time", UNSET)
        config_load_time: Union[Unset, datetime.datetime]
        if isinstance(_config_load_time, Unset):
            config_load_time = UNSET
        else:
            config_load_time = isoparse(_config_load_time)

        connections = d.pop("connections", UNSET)

        cores = d.pop("cores", UNSET)

        cpu = d.pop("cpu", UNSET)

        _gateway = d.pop("gateway", UNSET)
        gateway: Union[Unset, Gateway]
        if isinstance(_gateway, Unset):
            gateway = UNSET
        else:
            gateway = _gateway  # type: ignore[arg-type]

        git_commit = d.pop("git_commit", UNSET)

        go = d.pop("go", UNSET)

        gomaxprocs = d.pop("gomaxprocs", UNSET)

        host = d.pop("host", UNSET)

        http_base_path = d.pop("http_base_path", UNSET)

        http_host = d.pop("http_host", UNSET)

        http_port = d.pop("http_port", UNSET)

        http_req_stats = d.pop("http_req_stats", UNSET)
        https_port = d.pop("https_port", UNSET)

        in_bytes = d.pop("in_bytes", UNSET)

        in_msgs = d.pop("in_msgs", UNSET)

        _jetstream = d.pop("jetstream", UNSET)
        jetstream: Union[Unset, Jetstream]
        if isinstance(_jetstream, Unset):
            jetstream = UNSET
        else:
            jetstream = _jetstream  # type: ignore[arg-type]

        _leaf = d.pop("leaf", UNSET)
        leaf: Union[Unset, LeafNode]
        if isinstance(_leaf, Unset):
            leaf = UNSET
        else:
            leaf = _leaf  # type: ignore[arg-type]

        leafnodes = d.pop("leafnodes", UNSET)

        max_connections = d.pop("max_connections", UNSET)

        max_control_line = d.pop("max_control_line", UNSET)

        max_payload = d.pop("max_payload", UNSET)

        max_pending = d.pop("max_pending", UNSET)

        mem = d.pop("mem", UNSET)

        _now = d.pop("now", UNSET)
        now: Union[Unset, datetime.datetime]
        if isinstance(_now, Unset):
            now = UNSET
        else:
            now = isoparse(_now)

        out_bytes = d.pop("out_bytes", UNSET)

        out_msgs = d.pop("out_msgs", UNSET)

        ping_interval = d.pop("ping_interval", UNSET)

        ping_max = d.pop("ping_max", UNSET)

        port = d.pop("port", UNSET)

        proto = d.pop("proto", UNSET)

        remotes = d.pop("remotes", UNSET)

        routes = d.pop("routes", UNSET)

        server_id = d.pop("server_id", UNSET)

        server_name = d.pop("server_name", UNSET)

        slow_consumers = d.pop("slow_consumers", UNSET)

        start: Union[Unset, datetime.datetime]
        else:
            start = isoparse(_start)

        subscriptions = d.pop("subscriptions", UNSET)

        system_account = d.pop("system_account", UNSET)

        total_connections = d.pop("total_connections", UNSET)

        uptime = d.pop("uptime", UNSET)

        version = d.pop("version", UNSET)

        write_deadline = d.pop("write_deadline", UNSET)

        connection = cls(
            cluster=cluster,
            config_load_time=config_load_time,
            connections=connections,
            cores=cores,
            cpu=cpu,
            gateway=gateway,
            git_commit=git_commit,
            go=go,
            gomaxprocs=gomaxprocs,
            host=host,
            http_base_path=http_base_path,
            http_host=http_host,
            http_port=http_port,
            http_req_stats=http_req_stats,
            https_port=https_port,
            in_bytes=in_bytes,
            in_msgs=in_msgs,
            jetstream=jetstream,
            leaf=leaf,
            leafnodes=leafnodes,
            max_connections=max_connections,
            max_control_line=max_control_line,
            max_payload=max_payload,
            max_pending=max_pending,
            mem=mem,
            now=now,
            out_bytes=out_bytes,
            out_msgs=out_msgs,
            ping_interval=ping_interval,
            ping_max=ping_max,
            port=port,
            proto=proto,
            remotes=remotes,
            routes=routes,
            server_id=server_id,
            server_name=server_name,
            slow_consumers=slow_consumers,
            subscriptions=subscriptions,
            system_account=system_account,
            total_connections=total_connections,
            uptime=uptime,
            version=version,
            write_deadline=write_deadline,
        )

        connection.additional_properties = d
        return connection

    @property

class CountryCode(str, Enum):
    """An enumeration of all ISO-3166 alpha-2 country codes."""  # noqa: E501

    """# Afghanistan """  # noqa: E501
    AF = "AF"
    """# Åland Islands """  # noqa: E501
    AX = "AX"
    """# Albania """  # noqa: E501
    AL = "AL"
    """# Algeria """  # noqa: E501
    DZ = "DZ"
    """# American Samoa """  # noqa: E501
    AS = "AS"
    """# Andorra """  # noqa: E501
    AD = "AD"
    """# Angola """  # noqa: E501
    AO = "AO"
    """# Anguilla """  # noqa: E501
    AI = "AI"
    """# Antarctica """  # noqa: E501
    AQ = "AQ"
    """# Antigua and Barbuda """  # noqa: E501
    AG = "AG"
    """# Argentina """  # noqa: E501
    AR = "AR"
    """# Armenia """  # noqa: E501
    AM = "AM"
    """# Aruba """  # noqa: E501
    AW = "AW"
    """# Australia """  # noqa: E501
    AU = "AU"
    """# Austria """  # noqa: E501
    AT = "AT"
    """# Azerbaijan """  # noqa: E501
    AZ = "AZ"
    """# Bahamas """  # noqa: E501
    BS = "BS"
    """# Bahrain """  # noqa: E501
    BH = "BH"
    """# Bangladesh """  # noqa: E501
    BD = "BD"
    """# Barbados """  # noqa: E501
    BB = "BB"
    """# Belarus """  # noqa: E501
    BY = "BY"
    """# Belgium """  # noqa: E501
    BE = "BE"
    """# Belize """  # noqa: E501
    BZ = "BZ"
    """# Benin """  # noqa: E501
    BJ = "BJ"
    """# Bermuda """  # noqa: E501
    BM = "BM"
    """# Bhutan """  # noqa: E501
    BT = "BT"
    """# Bolivia (Plurinational State of) """  # noqa: E501
    BO = "BO"
    """# Bonaire, Sint Eustatius and Saba """  # noqa: E501
    BQ = "BQ"
    """# Bosnia and Herzegovina """  # noqa: E501
    BA = "BA"
    """# Botswana """  # noqa: E501
    BW = "BW"
    """# Bouvet Island """  # noqa: E501
    BV = "BV"
    """# Brazil """  # noqa: E501
    BR = "BR"
    """# British Indian Ocean Territory """  # noqa: E501
    IO = "IO"
    """# Brunei Darussalam """  # noqa: E501
    BN = "BN"
    """# Bulgaria """  # noqa: E501
    BG = "BG"
    """# Burkina Faso """  # noqa: E501
    BF = "BF"
    """# Burundi """  # noqa: E501
    BI = "BI"
    """# Cabo Verde """  # noqa: E501
    CV = "CV"
    """# Cambodia """  # noqa: E501
    KH = "KH"
    """# Cameroon """  # noqa: E501
    CM = "CM"
    """# Canada """  # noqa: E501
    CA = "CA"
    """# Cayman Islands """  # noqa: E501
    KY = "KY"
    """# Central African Republic """  # noqa: E501
    CF = "CF"
    """# Chad """  # noqa: E501
    TD = "TD"
    """# Chile """  # noqa: E501
    CL = "CL"
    """# China """  # noqa: E501
    CN = "CN"
    """# Christmas Island """  # noqa: E501
    CX = "CX"
    """# Cocos (Keeling) Islands """  # noqa: E501
    CC = "CC"
    """# Colombia """  # noqa: E501
    CO = "CO"
    """# Comoros """  # noqa: E501
    KM = "KM"
    """# Congo """  # noqa: E501
    CG = "CG"
    """# Congo (Democratic Republic of the) """  # noqa: E501
    CD = "CD"
    """# Cook Islands """  # noqa: E501
    CK = "CK"
    """# Costa Rica """  # noqa: E501
    CR = "CR"
    """# Côte d'Ivoire """  # noqa: E501
    CI = "CI"
    """# Croatia """  # noqa: E501
    HR = "HR"
    """# Cuba """  # noqa: E501
    CU = "CU"
    """# Curaçao """  # noqa: E501
    CW = "CW"
    """# Cyprus """  # noqa: E501
    CY = "CY"
    """# Czechia """  # noqa: E501
    CZ = "CZ"
    """# Denmark """  # noqa: E501
    DK = "DK"
    """# Djibouti """  # noqa: E501
    DJ = "DJ"
    """# Dominica """  # noqa: E501
    DM = "DM"
    """# Dominican Republic """  # noqa: E501
    DO = "DO"
    """# Ecuador """  # noqa: E501
    EC = "EC"
    """# Egypt """  # noqa: E501
    EG = "EG"
    """# El Salvador """  # noqa: E501
    SV = "SV"
    """# Equatorial Guinea """  # noqa: E501
    GQ = "GQ"
    """# Eritrea """  # noqa: E501
    ER = "ER"
    """# Estonia """  # noqa: E501
    EE = "EE"
    """# Ethiopia """  # noqa: E501
    ET = "ET"
    """# Falkland Islands (Malvinas) """  # noqa: E501
    FK = "FK"
    """# Faroe Islands """  # noqa: E501
    FO = "FO"
    """# Fiji """  # noqa: E501
    FJ = "FJ"
    """# Finland """  # noqa: E501
    FI = "FI"
    """# France """  # noqa: E501
    FR = "FR"
    """# French Guiana """  # noqa: E501
    GF = "GF"
    """# French Polynesia """  # noqa: E501
    PF = "PF"
    """# French Southern Territories """  # noqa: E501
    TF = "TF"
    """# Gabon """  # noqa: E501
    GA = "GA"
    """# Gambia """  # noqa: E501
    GM = "GM"
    """# Georgia """  # noqa: E501
    GE = "GE"
    """# Germany """  # noqa: E501
    DE = "DE"
    """# Ghana """  # noqa: E501
    GH = "GH"
    """# Gibraltar """  # noqa: E501
    GI = "GI"
    """# Greece """  # noqa: E501
    GR = "GR"
    """# Greenland """  # noqa: E501
    GL = "GL"
    """# Grenada """  # noqa: E501
    GD = "GD"
    """# Guadeloupe """  # noqa: E501
    GP = "GP"
    """# Guam """  # noqa: E501
    GU = "GU"
    """# Guatemala """  # noqa: E501
    GT = "GT"
    """# Guernsey """  # noqa: E501
    GG = "GG"
    """# Guinea """  # noqa: E501
    GN = "GN"
    """# Guinea-Bissau """  # noqa: E501
    GW = "GW"
    """# Guyana """  # noqa: E501
    GY = "GY"
    """# Haiti """  # noqa: E501
    HT = "HT"
    """# Heard Island and McDonald Islands """  # noqa: E501
    HM = "HM"
    """# Holy See """  # noqa: E501
    VA = "VA"
    """# Honduras """  # noqa: E501
    HN = "HN"
    """# Hong Kong """  # noqa: E501
    HK = "HK"
    """# Hungary """  # noqa: E501
    HU = "HU"
    """# Iceland """  # noqa: E501
    IS = "IS"
    """# India """  # noqa: E501
    IN = "IN"
    """# Indonesia """  # noqa: E501
    ID = "ID"
    """# Iran (Islamic Republic of) """  # noqa: E501
    IR = "IR"
    """# Iraq """  # noqa: E501
    IQ = "IQ"
    """# Ireland """  # noqa: E501
    IE = "IE"
    """# Isle of Man """  # noqa: E501
    IM = "IM"
    """# Israel """  # noqa: E501
    IL = "IL"
    """# Italy """  # noqa: E501
    IT = "IT"
    """# Jamaica """  # noqa: E501
    JM = "JM"
    """# Japan """  # noqa: E501
    JP = "JP"
    """# Jersey """  # noqa: E501
    JE = "JE"
    """# Jordan """  # noqa: E501
    JO = "JO"
    """# Kazakhstan """  # noqa: E501
    KZ = "KZ"
    """# Kenya """  # noqa: E501
    KE = "KE"
    """# Kiribati """  # noqa: E501
    KI = "KI"
    """# Korea (Democratic People's Republic of) """  # noqa: E501
    KP = "KP"
    """# Korea (Republic of) """  # noqa: E501
    KR = "KR"
    """# Kuwait """  # noqa: E501
    KW = "KW"
    """# Kyrgyzstan """  # noqa: E501
    KG = "KG"
    """# Lao People's Democratic Republic """  # noqa: E501
    LA = "LA"
    """# Latvia """  # noqa: E501
    LV = "LV"
    """# Lebanon """  # noqa: E501
    LB = "LB"
    """# Lesotho """  # noqa: E501
    LS = "LS"
    """# Liberia """  # noqa: E501
    LR = "LR"
    """# Libya """  # noqa: E501
    LY = "LY"
    """# Liechtenstein """  # noqa: E501
    LI = "LI"
    """# Lithuania """  # noqa: E501
    LT = "LT"
    """# Luxembourg """  # noqa: E501
    LU = "LU"
    """# Macao """  # noqa: E501
    MO = "MO"
    """# Macedonia (the former Yugoslav Republic of) """  # noqa: E501
    MK = "MK"
    """# Madagascar """  # noqa: E501
    MG = "MG"
    """# Malawi """  # noqa: E501
    MW = "MW"
    """# Malaysia """  # noqa: E501
    MY = "MY"
    """# Maldives """  # noqa: E501
    MV = "MV"
    """# Mali """  # noqa: E501
    ML = "ML"
    """# Malta """  # noqa: E501
    MT = "MT"
    """# Marshall Islands """  # noqa: E501
    MH = "MH"
    """# Martinique """  # noqa: E501
    MQ = "MQ"
    """# Mauritania """  # noqa: E501
    MR = "MR"
    """# Mauritius """  # noqa: E501
    MU = "MU"
    """# Mayotte """  # noqa: E501
    YT = "YT"
    """# Mexico """  # noqa: E501
    MX = "MX"
    """# Micronesia (Federated States of) """  # noqa: E501
    FM = "FM"
    """# Moldova (Republic of) """  # noqa: E501
    MD = "MD"
    """# Monaco """  # noqa: E501
    MC = "MC"
    """# Mongolia """  # noqa: E501
    MN = "MN"
    """# Montenegro """  # noqa: E501
    ME = "ME"
    """# Montserrat """  # noqa: E501
    MS = "MS"
    """# Morocco """  # noqa: E501
    MA = "MA"
    """# Mozambique """  # noqa: E501
    MZ = "MZ"
    """# Myanmar """  # noqa: E501
    MM = "MM"
    """# Namibia """  # noqa: E501
    NA = "NA"
    """# Nauru """  # noqa: E501
    NR = "NR"
    """# Nepal """  # noqa: E501
    NP = "NP"
    """# Netherlands """  # noqa: E501
    NL = "NL"
    """# New Caledonia """  # noqa: E501
    NC = "NC"
    """# New Zealand """  # noqa: E501
    NZ = "NZ"
    """# Nicaragua """  # noqa: E501
    NI = "NI"
    """# Niger """  # noqa: E501
    NE = "NE"
    """# Nigeria """  # noqa: E501
    NG = "NG"
    """# Niue """  # noqa: E501
    NU = "NU"
    """# Norfolk Island """  # noqa: E501
    NF = "NF"
    """# Northern Mariana Islands """  # noqa: E501
    MP = "MP"
    """# Norway """  # noqa: E501
    NO = "NO"
    """# Oman """  # noqa: E501
    OM = "OM"
    """# Pakistan """  # noqa: E501
    PK = "PK"
    """# Palau """  # noqa: E501
    PW = "PW"
    """# Palestine, State of """  # noqa: E501
    PS = "PS"
    """# Panama """  # noqa: E501
    PA = "PA"
    """# Papua New Guinea """  # noqa: E501
    PG = "PG"
    """# Paraguay """  # noqa: E501
    PY = "PY"
    """# Peru """  # noqa: E501
    PE = "PE"
    """# Philippines """  # noqa: E501
    PH = "PH"
    """# Pitcairn """  # noqa: E501
    PN = "PN"
    """# Poland """  # noqa: E501
    PL = "PL"
    """# Portugal """  # noqa: E501
    PT = "PT"
    """# Puerto Rico """  # noqa: E501
    PR = "PR"
    """# Qatar """  # noqa: E501
    QA = "QA"
    """# Réunion """  # noqa: E501
    RE = "RE"
    """# Romania """  # noqa: E501
    RO = "RO"
    """# Russian Federation """  # noqa: E501
    RU = "RU"
    """# Rwanda """  # noqa: E501
    RW = "RW"
    """# Saint Barthélemy """  # noqa: E501
    BL = "BL"
    """# Saint Helena, Ascension and Tristan da Cunha """  # noqa: E501
    SH = "SH"
    """# Saint Kitts and Nevis """  # noqa: E501
    KN = "KN"
    """# Saint Lucia """  # noqa: E501
    LC = "LC"
    """# Saint Martin (French part) """  # noqa: E501
    MF = "MF"
    """# Saint Pierre and Miquelon """  # noqa: E501
    PM = "PM"
    """# Saint Vincent and the Grenadines """  # noqa: E501
    VC = "VC"
    """# Samoa """  # noqa: E501
    WS = "WS"
    """# San Marino """  # noqa: E501
    SM = "SM"
    """# Sao Tome and Principe """  # noqa: E501
    ST = "ST"
    """# Saudi Arabia """  # noqa: E501
    SA = "SA"
    """# Senegal """  # noqa: E501
    SN = "SN"
    """# Serbia """  # noqa: E501
    RS = "RS"
    """# Seychelles """  # noqa: E501
    SC = "SC"
    """# Sierra Leone """  # noqa: E501
    SL = "SL"
    """# Singapore """  # noqa: E501
    SG = "SG"
    """# Sint Maarten (Dutch part) """  # noqa: E501
    SX = "SX"
    """# Slovakia """  # noqa: E501
    SK = "SK"
    """# Slovenia """  # noqa: E501
    SI = "SI"
    """# Solomon Islands """  # noqa: E501
    SB = "SB"
    """# Somalia """  # noqa: E501
    SO = "SO"
    """# South Africa """  # noqa: E501
    ZA = "ZA"
    """# South Georgia and the South Sandwich Islands """  # noqa: E501
    GS = "GS"
    """# South Sudan """  # noqa: E501
    SS = "SS"
    """# Spain """  # noqa: E501
    ES = "ES"
    """# Sri Lanka """  # noqa: E501
    LK = "LK"
    """# Sudan """  # noqa: E501
    SD = "SD"
    """# Suriname """  # noqa: E501
    SR = "SR"
    """# Svalbard and Jan Mayen """  # noqa: E501
    SJ = "SJ"
    """# Swaziland """  # noqa: E501
    SZ = "SZ"
    """# Sweden """  # noqa: E501
    SE = "SE"
    """# Switzerland """  # noqa: E501
    CH = "CH"
    """# Syrian Arab Republic """  # noqa: E501
    SY = "SY"
    """# Taiwan, Province of China """  # noqa: E501
    TW = "TW"
    """# Tajikistan """  # noqa: E501
    TJ = "TJ"
    """# Tanzania, United Republic of """  # noqa: E501
    TZ = "TZ"
    """# Thailand """  # noqa: E501
    TH = "TH"
    """# Timor-Leste """  # noqa: E501
    TL = "TL"
    """# Togo """  # noqa: E501
    TG = "TG"
    """# Tokelau """  # noqa: E501
    TK = "TK"
    """# Tonga """  # noqa: E501
    TO = "TO"
    """# Trinidad and Tobago """  # noqa: E501
    TT = "TT"
    """# Tunisia """  # noqa: E501
    TN = "TN"
    """# Turkey """  # noqa: E501
    TR = "TR"
    """# Turkmenistan """  # noqa: E501
    TM = "TM"
    """# Turks and Caicos Islands """  # noqa: E501
    TC = "TC"
    """# Tuvalu """  # noqa: E501
    TV = "TV"
    """# Uganda """  # noqa: E501
    UG = "UG"
    """# Ukraine """  # noqa: E501
    UA = "UA"
    """# United Arab Emirates """  # noqa: E501
    AE = "AE"
    """# United Kingdom of Great Britain and Northern Ireland """  # noqa: E501
    GB = "GB"
    """# United States of America """  # noqa: E501
    US = "US"
    """# United States Minor Outlying Islands """  # noqa: E501
    UM = "UM"
    """# Uruguay """  # noqa: E501
    UY = "UY"
    """# Uzbekistan """  # noqa: E501
    UZ = "UZ"
    """# Vanuatu """  # noqa: E501
    VU = "VU"
    """# Venezuela (Bolivarian Republic of) """  # noqa: E501
    VE = "VE"
    """# Viet Nam """  # noqa: E501
    VN = "VN"
    """# Virgin Islands (British) """  # noqa: E501
    VG = "VG"
    """# Virgin Islands (U.S.) """  # noqa: E501
    VI = "VI"
    """# Wallis and Futuna """  # noqa: E501
    WF = "WF"
    """# Western Sahara """  # noqa: E501
    EH = "EH"
    """# Yemen """  # noqa: E501
    YE = "YE"
    """# Zambia """  # noqa: E501
    ZM = "ZM"
    """# Zimbabwe """  # noqa: E501
    ZW = "ZW"

PC = TypeVar("PC", bound="Coupon")

class Coupon:
    """The resource representing a Coupon."""  # noqa: E501

    amount_off: Union[Unset, float] = UNSET
    deleted: Union[Unset, bool] = False
    percent_off: Union[Unset, float] = UNSET

        amount_off = self.amount_off
        deleted = self.deleted
        percent_off = self.percent_off

        if amount_off is not UNSET:
            field_dict["amount_off"] = amount_off
        if deleted is not UNSET:
            field_dict["deleted"] = deleted
        if percent_off is not UNSET:
            field_dict["percent_off"] = percent_off

    def from_dict(cls: Type[PC], src_dict: Dict[str, Any]) -> PC:
        amount_off = d.pop("amount_off", UNSET)

        deleted = d.pop("deleted", UNSET)

        percent_off = d.pop("percent_off", UNSET)

        coupon = cls(
            amount_off=amount_off,
            deleted=deleted,
            id=id,
            percent_off=percent_off,
        )

        coupon.additional_properties = d
        return coupon

    @property

class CreatedAtSortMode(str, Enum):
    """Supported set of sort modes for scanning by created_at only.

    Currently, we only support scanning in ascending order."""  # noqa: E501

    """# sort in increasing order of "created_at" """  # noqa: E501
    CREATED_AT_ASCENDING = "created-at-ascending"
    """# sort in decreasing order of "created_at" """  # noqa: E501
    CREATED_AT_DESCENDING = "created-at-descending"

class Currency(str, Enum):
    """Currency is the list of supported currencies.

    This comes from the Stripe API docs: For more details see <https://support.stripe.com/questions/which-currencies-does-stripe-support>.

    """# United Arab Emirates Dirham """  # noqa: E501
    AED = "aed"
    """# Afghan Afghani """  # noqa: E501
    AFN = "afn"
    """# Albanian Lek """  # noqa: E501
    ALL = "all"
    """# Armenian Dram """  # noqa: E501
    AMD = "amd"
    """# Netherlands Antillean Gulden """  # noqa: E501
    ANG = "ang"
    """# Angolan Kwanza """  # noqa: E501
    AOA = "aoa"
    """# Argentine Peso """  # noqa: E501
    ARS = "ars"
    """# Australian Dollar """  # noqa: E501
    AUD = "aud"
    """# Aruban Florin """  # noqa: E501
    AWG = "awg"
    """# Azerbaijani Manat """  # noqa: E501
    AZN = "azn"
    """# Bosnia & Herzegovina Convertible Mark """  # noqa: E501
    BAM = "bam"
    """# Barbadian Dollar """  # noqa: E501
    BBD = "bbd"
    """# Bangladeshi Taka """  # noqa: E501
    BDT = "bdt"
    """# Bulgarian Lev """  # noqa: E501
    BGN = "bgn"
    """# Burundian Franc """  # noqa: E501
    BIF = "bif"
    """# Bermudian Dollar """  # noqa: E501
    BMD = "bmd"
    """# Brunei Dollar """  # noqa: E501
    BND = "bnd"
    """# Bolivian Boliviano """  # noqa: E501
    BOB = "bob"
    """# Brazilian Real """  # noqa: E501
    BRL = "brl"
    """# Bahamian Dollar """  # noqa: E501
    BSD = "bsd"
    """# Botswana Pula """  # noqa: E501
    BWP = "bwp"
    """# Belize Dollar """  # noqa: E501
    BZD = "bzd"
    """# Canadian Dollar """  # noqa: E501
    CAD = "cad"
    """# Congolese Franc """  # noqa: E501
    CDF = "cdf"
    """# Swiss Franc """  # noqa: E501
    CHF = "chf"
    """# Chilean Peso """  # noqa: E501
    CLP = "clp"
    """# Chinese Renminbi Yuan """  # noqa: E501
    CNY = "cny"
    """# Colombian Peso """  # noqa: E501
    COP = "cop"
    """# Costa Rican Colón """  # noqa: E501
    CRC = "crc"
    """# Cape Verdean Escudo """  # noqa: E501
    CVE = "cve"
    """# Czech Koruna """  # noqa: E501
    CZK = "czk"
    """# Djiboutian Franc """  # noqa: E501
    DJF = "djf"
    """# Danish Krone """  # noqa: E501
    DKK = "dkk"
    """# Dominican Peso """  # noqa: E501
    DOP = "dop"
    """# Algerian Dinar """  # noqa: E501
    DZD = "dzd"
    """# Estonian Kroon """  # noqa: E501
    EEK = "eek"
    """# Egyptian Pound """  # noqa: E501
    EGP = "egp"
    """# Ethiopian Birr """  # noqa: E501
    ETB = "etb"
    """# Euro """  # noqa: E501
    EUR = "eur"
    """# Fijian Dollar """  # noqa: E501
    FJD = "fjd"
    """# Falkland Islands Pound """  # noqa: E501
    FKP = "fkp"
    """# British Pound """  # noqa: E501
    GBP = "gbp"
    """# Georgian Lari """  # noqa: E501
    GEL = "gel"
    """# Gibraltar Pound """  # noqa: E501
    GIP = "gip"
    """# Gambian Dalasi """  # noqa: E501
    GMD = "gmd"
    """# Guinean Franc """  # noqa: E501
    GNF = "gnf"
    """# Guatemalan Quetzal """  # noqa: E501
    GTQ = "gtq"
    """# Guyanese Dollar """  # noqa: E501
    GYD = "gyd"
    """# Hong Kong Dollar """  # noqa: E501
    HKD = "hkd"
    """# Honduran Lempira """  # noqa: E501
    HNL = "hnl"
    """# Croatian Kuna """  # noqa: E501
    HRK = "hrk"
    """# Haitian Gourde """  # noqa: E501
    HTG = "htg"
    """# Hungarian Forint """  # noqa: E501
    HUF = "huf"
    """# Indonesian Rupiah """  # noqa: E501
    IDR = "idr"
    """# Israeli New Sheqel """  # noqa: E501
    ILS = "ils"
    """# Indian Rupee """  # noqa: E501
    INR = "inr"
    """# Icelandic Króna """  # noqa: E501
    ISK = "isk"
    """# Jamaican Dollar """  # noqa: E501
    JMD = "jmd"
    """# Japanese Yen """  # noqa: E501
    JPY = "jpy"
    """# Kenyan Shilling """  # noqa: E501
    KES = "kes"
    """# Kyrgyzstani Som """  # noqa: E501
    KGS = "kgs"
    """# Cambodian Riel """  # noqa: E501
    KHR = "khr"
    """# Comorian Franc """  # noqa: E501
    KMF = "kmf"
    """# South Korean Won """  # noqa: E501
    KRW = "krw"
    """# Cayman Islands Dollar """  # noqa: E501
    KYD = "kyd"
    """# Kazakhstani Tenge """  # noqa: E501
    KZT = "kzt"
    """# Lao Kip """  # noqa: E501
    LAK = "lak"
    """# Lebanese Pound """  # noqa: E501
    LBP = "lbp"
    """# Sri Lankan Rupee """  # noqa: E501
    LKR = "lkr"
    """# Liberian Dollar """  # noqa: E501
    LRD = "lrd"
    """# Lesotho Loti """  # noqa: E501
    LSL = "lsl"
    """# Lithuanian Litas """  # noqa: E501
    LTL = "ltl"
    """# Latvian Lats """  # noqa: E501
    LVL = "lvl"
    """# Moroccan Dirham """  # noqa: E501
    MAD = "mad"
    """# Moldovan Leu """  # noqa: E501
    MDL = "mdl"
    """# Malagasy Ariary """  # noqa: E501
    MGA = "mga"
    """# Macedonian Denar """  # noqa: E501
    MKD = "mkd"
    """# Mongolian Tögrög """  # noqa: E501
    MNT = "mnt"
    """# Macanese Pataca """  # noqa: E501
    MOP = "mop"
    """# Mauritanian Ouguiya """  # noqa: E501
    MRO = "mro"
    """# Mauritian Rupee """  # noqa: E501
    MUR = "mur"
    """# Maldivian Rufiyaa """  # noqa: E501
    MVR = "mvr"
    """# Malawian Kwacha """  # noqa: E501
    MWK = "mwk"
    """# Mexican Peso """  # noqa: E501
    MXN = "mxn"
    """# Malaysian Ringgit """  # noqa: E501
    MYR = "myr"
    """# Mozambican Metical """  # noqa: E501
    MZN = "mzn"
    """# Namibian Dollar """  # noqa: E501
    NAD = "nad"
    """# Nigerian Naira """  # noqa: E501
    NGN = "ngn"
    """# Nicaraguan Córdoba """  # noqa: E501
    NIO = "nio"
    """# Norwegian Krone """  # noqa: E501
    NOK = "nok"
    """# Nepalese Rupee """  # noqa: E501
    NPR = "npr"
    """# New Zealand Dollar """  # noqa: E501
    NZD = "nzd"
    """# Panamanian Balboa """  # noqa: E501
    PAB = "pab"
    """# Peruvian Nuevo Sol """  # noqa: E501
    PEN = "pen"
    """# Papua New Guinean Kina """  # noqa: E501
    PGK = "pgk"
    """# Philippine Peso """  # noqa: E501
    PHP = "php"
    """# Pakistani Rupee """  # noqa: E501
    PKR = "pkr"
    """# Polish Złoty """  # noqa: E501
    PLN = "pln"
    """# Paraguayan Guaraní """  # noqa: E501
    PYG = "pyg"
    """# Qatari Riyal """  # noqa: E501
    QAR = "qar"
    """# Romanian Leu """  # noqa: E501
    RON = "ron"
    """# Serbian Dinar """  # noqa: E501
    RSD = "rsd"
    """# Russian Ruble """  # noqa: E501
    RUB = "rub"
    """# Rwandan Franc """  # noqa: E501
    RWF = "rwf"
    """# Saudi Riyal """  # noqa: E501
    SAR = "sar"
    """# Solomon Islands Dollar """  # noqa: E501
    SBD = "sbd"
    """# Seychellois Rupee """  # noqa: E501
    SCR = "scr"
    """# Swedish Krona """  # noqa: E501
    SEK = "sek"
    """# Singapore Dollar """  # noqa: E501
    SGD = "sgd"
    """# Saint Helenian Pound """  # noqa: E501
    SHP = "shp"
    """# Sierra Leonean Leone """  # noqa: E501
    SLL = "sll"
    """# Somali Shilling """  # noqa: E501
    SOS = "sos"
    """# Surinamese Dollar """  # noqa: E501
    SRD = "srd"
    """# São Tomé and Príncipe Dobra """  # noqa: E501
    STD = "std"
    """# Salvadoran Colón """  # noqa: E501
    SVC = "svc"
    """# Swazi Lilangeni """  # noqa: E501
    SZL = "szl"
    """# Thai Baht """  # noqa: E501
    THB = "thb"
    """# Tajikistani Somoni """  # noqa: E501
    TJS = "tjs"
    """# Tongan Paʻanga """  # noqa: E501
    TOP = "top"
    """# Turkish Lira """  # noqa: E501
    TRY = "try"
    """# Trinidad and Tobago Dollar """  # noqa: E501
    TTD = "ttd"
    """# New Taiwan Dollar """  # noqa: E501
    TWD = "twd"
    """# Tanzanian Shilling """  # noqa: E501
    TZS = "tzs"
    """# Ukrainian Hryvnia """  # noqa: E501
    UAH = "uah"
    """# Ugandan Shilling """  # noqa: E501
    UGX = "ugx"
    """# United States Dollar """  # noqa: E501
    USD = "usd"
    """# Uruguayan Peso """  # noqa: E501
    UYU = "uyu"
    """# Uzbekistani Som """  # noqa: E501
    UZS = "uzs"
    """# Venezuelan Bolívar """  # noqa: E501
    VEF = "vef"
    """# Vietnamese Đồng """  # noqa: E501
    VND = "vnd"
    """# Vanuatu Vatu """  # noqa: E501
    VUV = "vuv"
    """# Samoan Tala """  # noqa: E501
    WST = "wst"
    """# Central African Cfa Franc """  # noqa: E501
    XAF = "xaf"
    """# East Caribbean Dollar """  # noqa: E501
    XCD = "xcd"
    """# West African Cfa Franc """  # noqa: E501
    XOF = "xof"
    """# Cfp Franc """  # noqa: E501
    XPF = "xpf"
    """# Yemeni Rial """  # noqa: E501
    YER = "yer"
    """# South African Rand """  # noqa: E501
    ZAR = "zar"
    """# Zambian Kwacha """  # noqa: E501
    ZMW = "zmw"

from ..models.currency import Currency

US = TypeVar("US", bound="Customer")

class Customer:
    """The resource representing a payment "Customer"."""  # noqa: E501

    balance: Union[Unset, float] = UNSET
    currency: Union[Unset, Currency] = UNSET
    delinquent: Union[Unset, bool] = False
    metadata: Union[Unset, Any] = UNSET

        balance = self.balance
        if not isinstance(self.currency, Unset):
            currency = self.currency
        delinquent = self.delinquent
        metadata = self.metadata

        if balance is not UNSET:
            field_dict["balance"] = balance
        if currency is not UNSET:
            field_dict["currency"] = currency
        if delinquent is not UNSET:
            field_dict["delinquent"] = delinquent
        if metadata is not UNSET:
            field_dict["metadata"] = metadata

    def from_dict(cls: Type[US], src_dict: Dict[str, Any]) -> US:
        else:

        balance = d.pop("balance", UNSET)

        else:

        _currency = d.pop("currency", UNSET)
        currency: Union[Unset, Currency]
        if isinstance(_currency, Unset):
            currency = UNSET
        else:
            currency = _currency  # type: ignore[arg-type]

        delinquent = d.pop("delinquent", UNSET)

        metadata = d.pop("metadata", UNSET)

        customer = cls(
            balance=balance,
            currency=currency,
            delinquent=delinquent,
            id=id,
            metadata=metadata,
        )

        customer.additional_properties = d
        return customer

    @property

KQ = TypeVar("KQ", bound="CustomerBalance")

class CustomerBalance:
    """A balance for a user.

    This holds information about the financial balance for the user."""  # noqa: E501

    monthly_credits_remaining: Union[Unset, float] = UNSET
    pre_pay_cash_remaining: Union[Unset, float] = UNSET
    pre_pay_credits_remaining: Union[Unset, float] = UNSET
    total_due: Union[Unset, float] = UNSET

        monthly_credits_remaining = self.monthly_credits_remaining
        pre_pay_cash_remaining = self.pre_pay_cash_remaining
        pre_pay_credits_remaining = self.pre_pay_credits_remaining
        total_due = self.total_due

        if monthly_credits_remaining is not UNSET:
            field_dict["monthly_credits_remaining"] = monthly_credits_remaining
        if pre_pay_cash_remaining is not UNSET:
            field_dict["pre_pay_cash_remaining"] = pre_pay_cash_remaining
        if pre_pay_credits_remaining is not UNSET:
            field_dict["pre_pay_credits_remaining"] = pre_pay_credits_remaining
        if total_due is not UNSET:
            field_dict["total_due"] = total_due

    def from_dict(cls: Type[KQ], src_dict: Dict[str, Any]) -> KQ:
        else:

            id = UNSET
        else:

        monthly_credits_remaining = d.pop("monthly_credits_remaining", UNSET)

        pre_pay_cash_remaining = d.pop("pre_pay_cash_remaining", UNSET)

        pre_pay_credits_remaining = d.pop("pre_pay_credits_remaining", UNSET)

        total_due = d.pop("total_due", UNSET)

        else:

        customer_balance = cls(
            id=id,
            monthly_credits_remaining=monthly_credits_remaining,
            pre_pay_cash_remaining=pre_pay_cash_remaining,
            pre_pay_credits_remaining=pre_pay_credits_remaining,
            total_due=total_due,
        )

        customer_balance.additional_properties = d
        return customer_balance

    @property

from ..models.o_auth2_grant_type import OAuth2GrantType

FH = TypeVar("FH", bound="DeviceAccessTokenRequestForm")

class DeviceAccessTokenRequestForm:
    """The form for a device access token request."""  # noqa: E501

    client_id: Union[Unset, str] = UNSET
    device_code: Union[Unset, str] = UNSET
    grant_type: Union[Unset, OAuth2GrantType] = UNSET

        client_id = self.client_id
        device_code = self.device_code
        if not isinstance(self.grant_type, Unset):
            grant_type = self.grant_type

        if client_id is not UNSET:
            field_dict["client_id"] = client_id
        if device_code is not UNSET:
            field_dict["device_code"] = device_code
        if grant_type is not UNSET:
            field_dict["grant_type"] = grant_type

    def from_dict(cls: Type[FH], src_dict: Dict[str, Any]) -> FH:
        client_id = d.pop("client_id", UNSET)

        device_code = d.pop("device_code", UNSET)

        _grant_type = d.pop("grant_type", UNSET)
        grant_type: Union[Unset, OAuth2GrantType]
        if isinstance(_grant_type, Unset):
            grant_type = UNSET
        else:
            grant_type = _grant_type  # type: ignore[arg-type]

        device_access_token_request_form = cls(
            client_id=client_id,
            device_code=device_code,
            grant_type=grant_type,
        )

        device_access_token_request_form.additional_properties = d
        return device_access_token_request_form

    @property

NH = TypeVar("NH", bound="DeviceAuthRequestForm")

class DeviceAuthRequestForm:
    """The request parameters for the OAuth 2.0 Device Authorization Grant flow."""  # noqa: E501

    def from_dict(cls: Type[NH], src_dict: Dict[str, Any]) -> NH:

        device_auth_request_form = cls(
        )

        device_auth_request_form.additional_properties = d
        return device_auth_request_form

    @property

BB = TypeVar("BB", bound="DeviceAuthVerifyParams")

class DeviceAuthVerifyParams:
    """The request parameters to verify the `user_code` for the OAuth 2.0 Device Authorization Grant."""  # noqa: E501

    user_code: Union[Unset, str] = UNSET

        user_code = self.user_code

        if user_code is not UNSET:
            field_dict["user_code"] = user_code

    def from_dict(cls: Type[BB], src_dict: Dict[str, Any]) -> BB:
        user_code = d.pop("user_code", UNSET)

        device_auth_verify_params = cls(
            user_code=user_code,
        )

        device_auth_verify_params.additional_properties = d
        return device_auth_verify_params

    @property

class Direction(str, Enum):
    """Specifies the sign of a co-ordinate axis."""  # noqa: E501

    """# Increasing numbers. """  # noqa: E501
    POSITIVE = "positive"
    """# Decreasing numbers. """  # noqa: E501
    NEGATIVE = "negative"

from ..models.coupon import Coupon

PJ = TypeVar("PJ", bound="Discount")

class Discount:
    """The resource representing a Discount."""  # noqa: E501

    coupon: Union[Unset, Coupon] = UNSET

        if not isinstance(self.coupon, Unset):
            coupon = self.coupon

        if coupon is not UNSET:
            field_dict["coupon"] = coupon

    def from_dict(cls: Type[PJ], src_dict: Dict[str, Any]) -> PJ:
        _coupon = d.pop("coupon", UNSET)
        coupon: Union[Unset, Coupon]
        if isinstance(_coupon, Unset):
            coupon = UNSET
        else:
            coupon = _coupon  # type: ignore[arg-type]

        discount = cls(
            coupon=coupon,
        )

        discount.additional_properties = d
        return discount

    @property

from ..models.commit import Commit
from ..models.plugins_info import PluginsInfo
from ..models.registry_service_config import RegistryServiceConfig
from ..models.system_info_cgroup_driver_enum import SystemInfoCgroupDriverEnum
from ..models.system_info_cgroup_version_enum import SystemInfoCgroupVersionEnum
from ..models.system_info_isolation_enum import SystemInfoIsolationEnum

TV = TypeVar("TV", bound="DockerSystemInfo")

class DockerSystemInfo:
    """Docker system info."""  # noqa: E501

    architecture: Union[Unset, str] = UNSET
    bridge_nf_ip6tables: Union[Unset, bool] = False
    bridge_nf_iptables: Union[Unset, bool] = False
    cgroup_driver: Union[Unset, SystemInfoCgroupDriverEnum] = UNSET
    cgroup_version: Union[Unset, SystemInfoCgroupVersionEnum] = UNSET
    cluster_advertise: Union[Unset, str] = UNSET
    cluster_store: Union[Unset, str] = UNSET
    containerd_commit: Union[Unset, Commit] = UNSET
    containers: Union[Unset, int] = UNSET
    containers_paused: Union[Unset, int] = UNSET
    containers_running: Union[Unset, int] = UNSET
    containers_stopped: Union[Unset, int] = UNSET
    cpu_cfs_period: Union[Unset, bool] = False
    cpu_cfs_quota: Union[Unset, bool] = False
    cpu_set: Union[Unset, bool] = False
    cpu_shares: Union[Unset, bool] = False
    debug: Union[Unset, bool] = False
    from ..models.system_info_default_address_pools import SystemInfoDefaultAddressPools

    default_address_pools: Union[Unset, List[SystemInfoDefaultAddressPools]] = UNSET
    default_runtime: Union[Unset, str] = UNSET
    docker_root_dir: Union[Unset, str] = UNSET
    driver: Union[Unset, str] = UNSET
    driver_status: Union[Unset, List[List[str]]] = UNSET
    experimental_build: Union[Unset, bool] = False
    http_proxy: Union[Unset, str] = UNSET
    https_proxy: Union[Unset, str] = UNSET
    images: Union[Unset, int] = UNSET
    index_server_address: Union[Unset, str] = UNSET
    init_binary: Union[Unset, str] = UNSET
    init_commit: Union[Unset, Commit] = UNSET
    ipv4_forwarding: Union[Unset, bool] = False
    isolation: Union[Unset, SystemInfoIsolationEnum] = UNSET
    kernel_memory: Union[Unset, bool] = False
    kernel_memory_tcp: Union[Unset, bool] = False
    kernel_version: Union[Unset, str] = UNSET
    labels: Union[Unset, List[str]] = UNSET
    live_restore_enabled: Union[Unset, bool] = False
    logging_driver: Union[Unset, str] = UNSET
    mem_total: Union[Unset, int] = UNSET
    memory_limit: Union[Unset, bool] = False
    n_events_listener: Union[Unset, int] = UNSET
    n_fd: Union[Unset, int] = UNSET
    ncpu: Union[Unset, int] = UNSET
    no_proxy: Union[Unset, str] = UNSET
    oom_kill_disable: Union[Unset, bool] = False
    operating_system: Union[Unset, str] = UNSET
    os_type: Union[Unset, str] = UNSET
    os_version: Union[Unset, str] = UNSET
    pids_limit: Union[Unset, bool] = False
    plugins: Union[Unset, PluginsInfo] = UNSET
    product_license: Union[Unset, str] = UNSET
    registry_config: Union[Unset, RegistryServiceConfig] = UNSET
    runc_commit: Union[Unset, Commit] = UNSET
    runtimes: Union[Unset, Any] = UNSET
    security_options: Union[Unset, List[str]] = UNSET
    server_version: Union[Unset, str] = UNSET
    swap_limit: Union[Unset, bool] = False
    system_time: Union[Unset, str] = UNSET
    warnings: Union[Unset, List[str]] = UNSET

        architecture = self.architecture
        bridge_nf_ip6tables = self.bridge_nf_ip6tables
        bridge_nf_iptables = self.bridge_nf_iptables
        if not isinstance(self.cgroup_driver, Unset):
            cgroup_driver = self.cgroup_driver
        if not isinstance(self.cgroup_version, Unset):
            cgroup_version = self.cgroup_version
        cluster_advertise = self.cluster_advertise
        cluster_store = self.cluster_store
        if not isinstance(self.containerd_commit, Unset):
            containerd_commit = self.containerd_commit
        containers = self.containers
        containers_paused = self.containers_paused
        containers_running = self.containers_running
        containers_stopped = self.containers_stopped
        cpu_cfs_period = self.cpu_cfs_period
        cpu_cfs_quota = self.cpu_cfs_quota
        cpu_set = self.cpu_set
        cpu_shares = self.cpu_shares
        debug = self.debug
        from ..models.system_info_default_address_pools import (
            SystemInfoDefaultAddressPools,
        )

        default_address_pools: Union[Unset, List[SystemInfoDefaultAddressPools]] = UNSET
        if not isinstance(self.default_address_pools, Unset):
            default_address_pools = self.default_address_pools
        default_runtime = self.default_runtime
        docker_root_dir = self.docker_root_dir
        driver = self.driver
        driver_status: Union[Unset, List[List[str]]] = UNSET
        if not isinstance(self.driver_status, Unset):
            driver_status = self.driver_status
        experimental_build = self.experimental_build
        http_proxy = self.http_proxy
        https_proxy = self.https_proxy
        images = self.images
        index_server_address = self.index_server_address
        init_binary = self.init_binary
        if not isinstance(self.init_commit, Unset):
            init_commit = self.init_commit
        ipv4_forwarding = self.ipv4_forwarding
        if not isinstance(self.isolation, Unset):
            isolation = self.isolation
        kernel_memory = self.kernel_memory
        kernel_memory_tcp = self.kernel_memory_tcp
        kernel_version = self.kernel_version
        labels: Union[Unset, List[str]] = UNSET
        if not isinstance(self.labels, Unset):
            labels = self.labels
        live_restore_enabled = self.live_restore_enabled
        logging_driver = self.logging_driver
        mem_total = self.mem_total
        memory_limit = self.memory_limit
        n_events_listener = self.n_events_listener
        n_fd = self.n_fd
        ncpu = self.ncpu
        no_proxy = self.no_proxy
        oom_kill_disable = self.oom_kill_disable
        operating_system = self.operating_system
        os_type = self.os_type
        os_version = self.os_version
        pids_limit = self.pids_limit
        if not isinstance(self.plugins, Unset):
            plugins = self.plugins
        product_license = self.product_license
        if not isinstance(self.registry_config, Unset):
            registry_config = self.registry_config
        if not isinstance(self.runc_commit, Unset):
            runc_commit = self.runc_commit
        runtimes = self.runtimes
        security_options: Union[Unset, List[str]] = UNSET
        if not isinstance(self.security_options, Unset):
            security_options = self.security_options
        server_version = self.server_version
        swap_limit = self.swap_limit
        system_time = self.system_time
        warnings: Union[Unset, List[str]] = UNSET
        if not isinstance(self.warnings, Unset):
            warnings = self.warnings

        if architecture is not UNSET:
            field_dict["architecture"] = architecture
        if bridge_nf_ip6tables is not UNSET:
            field_dict["bridge_nf_ip6tables"] = bridge_nf_ip6tables
        if bridge_nf_iptables is not UNSET:
            field_dict["bridge_nf_iptables"] = bridge_nf_iptables
        if cgroup_driver is not UNSET:
            field_dict["cgroup_driver"] = cgroup_driver
        if cgroup_version is not UNSET:
            field_dict["cgroup_version"] = cgroup_version
        if cluster_advertise is not UNSET:
            field_dict["cluster_advertise"] = cluster_advertise
        if cluster_store is not UNSET:
            field_dict["cluster_store"] = cluster_store
        if containerd_commit is not UNSET:
            field_dict["containerd_commit"] = containerd_commit
        if containers is not UNSET:
            field_dict["containers"] = containers
        if containers_paused is not UNSET:
            field_dict["containers_paused"] = containers_paused
        if containers_running is not UNSET:
            field_dict["containers_running"] = containers_running
        if containers_stopped is not UNSET:
            field_dict["containers_stopped"] = containers_stopped
        if cpu_cfs_period is not UNSET:
            field_dict["cpu_cfs_period"] = cpu_cfs_period
        if cpu_cfs_quota is not UNSET:
            field_dict["cpu_cfs_quota"] = cpu_cfs_quota
        if cpu_set is not UNSET:
            field_dict["cpu_set"] = cpu_set
        if cpu_shares is not UNSET:
            field_dict["cpu_shares"] = cpu_shares
        if debug is not UNSET:
            field_dict["debug"] = debug
        if default_address_pools is not UNSET:
            field_dict["default_address_pools"] = default_address_pools
        if default_runtime is not UNSET:
            field_dict["default_runtime"] = default_runtime
        if docker_root_dir is not UNSET:
            field_dict["docker_root_dir"] = docker_root_dir
        if driver is not UNSET:
            field_dict["driver"] = driver
        if driver_status is not UNSET:
            field_dict["driver_status"] = driver_status
        if experimental_build is not UNSET:
            field_dict["experimental_build"] = experimental_build
        if http_proxy is not UNSET:
            field_dict["http_proxy"] = http_proxy
        if https_proxy is not UNSET:
            field_dict["https_proxy"] = https_proxy
        if images is not UNSET:
            field_dict["images"] = images
        if index_server_address is not UNSET:
            field_dict["index_server_address"] = index_server_address
        if init_binary is not UNSET:
            field_dict["init_binary"] = init_binary
        if init_commit is not UNSET:
            field_dict["init_commit"] = init_commit
        if ipv4_forwarding is not UNSET:
            field_dict["ipv4_forwarding"] = ipv4_forwarding
        if isolation is not UNSET:
            field_dict["isolation"] = isolation
        if kernel_memory is not UNSET:
            field_dict["kernel_memory"] = kernel_memory
        if kernel_memory_tcp is not UNSET:
            field_dict["kernel_memory_tcp"] = kernel_memory_tcp
        if kernel_version is not UNSET:
            field_dict["kernel_version"] = kernel_version
        if labels is not UNSET:
            field_dict["labels"] = labels
        if live_restore_enabled is not UNSET:
            field_dict["live_restore_enabled"] = live_restore_enabled
        if logging_driver is not UNSET:
            field_dict["logging_driver"] = logging_driver
        if mem_total is not UNSET:
            field_dict["mem_total"] = mem_total
        if memory_limit is not UNSET:
            field_dict["memory_limit"] = memory_limit
        if n_events_listener is not UNSET:
            field_dict["n_events_listener"] = n_events_listener
        if n_fd is not UNSET:
            field_dict["n_fd"] = n_fd
        if ncpu is not UNSET:
            field_dict["ncpu"] = ncpu
        if no_proxy is not UNSET:
            field_dict["no_proxy"] = no_proxy
        if oom_kill_disable is not UNSET:
            field_dict["oom_kill_disable"] = oom_kill_disable
        if operating_system is not UNSET:
            field_dict["operating_system"] = operating_system
        if os_type is not UNSET:
            field_dict["os_type"] = os_type
        if os_version is not UNSET:
            field_dict["os_version"] = os_version
        if pids_limit is not UNSET:
            field_dict["pids_limit"] = pids_limit
        if plugins is not UNSET:
            field_dict["plugins"] = plugins
        if product_license is not UNSET:
            field_dict["product_license"] = product_license
        if registry_config is not UNSET:
            field_dict["registry_config"] = registry_config
        if runc_commit is not UNSET:
            field_dict["runc_commit"] = runc_commit
        if runtimes is not UNSET:
            field_dict["runtimes"] = runtimes
        if security_options is not UNSET:
            field_dict["security_options"] = security_options
        if server_version is not UNSET:
            field_dict["server_version"] = server_version
        if swap_limit is not UNSET:
            field_dict["swap_limit"] = swap_limit
        if system_time is not UNSET:
            field_dict["system_time"] = system_time
        if warnings is not UNSET:
            field_dict["warnings"] = warnings

    def from_dict(cls: Type[TV], src_dict: Dict[str, Any]) -> TV:
        architecture = d.pop("architecture", UNSET)

        bridge_nf_ip6tables = d.pop("bridge_nf_ip6tables", UNSET)

        bridge_nf_iptables = d.pop("bridge_nf_iptables", UNSET)

        _cgroup_driver = d.pop("cgroup_driver", UNSET)
        cgroup_driver: Union[Unset, SystemInfoCgroupDriverEnum]
        if isinstance(_cgroup_driver, Unset):
            cgroup_driver = UNSET
        else:
            cgroup_driver = _cgroup_driver  # type: ignore[arg-type]

        _cgroup_version = d.pop("cgroup_version", UNSET)
        cgroup_version: Union[Unset, SystemInfoCgroupVersionEnum]
        if isinstance(_cgroup_version, Unset):
            cgroup_version = UNSET
        else:
            cgroup_version = _cgroup_version  # type: ignore[arg-type]

        cluster_advertise = d.pop("cluster_advertise", UNSET)

        cluster_store = d.pop("cluster_store", UNSET)

        _containerd_commit = d.pop("containerd_commit", UNSET)
        containerd_commit: Union[Unset, Commit]
        if isinstance(_containerd_commit, Unset):
            containerd_commit = UNSET
        else:
            containerd_commit = _containerd_commit  # type: ignore[arg-type]

        containers = d.pop("containers", UNSET)

        containers_paused = d.pop("containers_paused", UNSET)

        containers_running = d.pop("containers_running", UNSET)

        containers_stopped = d.pop("containers_stopped", UNSET)

        cpu_cfs_period = d.pop("cpu_cfs_period", UNSET)

        cpu_cfs_quota = d.pop("cpu_cfs_quota", UNSET)

        cpu_set = d.pop("cpu_set", UNSET)

        cpu_shares = d.pop("cpu_shares", UNSET)

        debug = d.pop("debug", UNSET)

        )

        default_address_pools = cast(
            List[SystemInfoDefaultAddressPools], d.pop("default_address_pools", UNSET)
        )

        default_runtime = d.pop("default_runtime", UNSET)

        docker_root_dir = d.pop("docker_root_dir", UNSET)

        driver = d.pop("driver", UNSET)

        driver_status = cast(List[List[str]], d.pop("driver_status", UNSET))

        experimental_build = d.pop("experimental_build", UNSET)

        http_proxy = d.pop("http_proxy", UNSET)

        https_proxy = d.pop("https_proxy", UNSET)

        images = d.pop("images", UNSET)

        index_server_address = d.pop("index_server_address", UNSET)

        init_binary = d.pop("init_binary", UNSET)

        _init_commit = d.pop("init_commit", UNSET)
        init_commit: Union[Unset, Commit]
        if isinstance(_init_commit, Unset):
            init_commit = UNSET
        else:
            init_commit = _init_commit  # type: ignore[arg-type]

        ipv4_forwarding = d.pop("ipv4_forwarding", UNSET)

        _isolation = d.pop("isolation", UNSET)
        isolation: Union[Unset, SystemInfoIsolationEnum]
        if isinstance(_isolation, Unset):
            isolation = UNSET
        else:
            isolation = _isolation  # type: ignore[arg-type]

        kernel_memory = d.pop("kernel_memory", UNSET)

        kernel_memory_tcp = d.pop("kernel_memory_tcp", UNSET)

        kernel_version = d.pop("kernel_version", UNSET)

        labels = cast(List[str], d.pop("labels", UNSET))

        live_restore_enabled = d.pop("live_restore_enabled", UNSET)

        logging_driver = d.pop("logging_driver", UNSET)

        mem_total = d.pop("mem_total", UNSET)

        memory_limit = d.pop("memory_limit", UNSET)

        n_events_listener = d.pop("n_events_listener", UNSET)

        n_fd = d.pop("n_fd", UNSET)

        ncpu = d.pop("ncpu", UNSET)

        no_proxy = d.pop("no_proxy", UNSET)

        oom_kill_disable = d.pop("oom_kill_disable", UNSET)

        operating_system = d.pop("operating_system", UNSET)

        os_type = d.pop("os_type", UNSET)

        os_version = d.pop("os_version", UNSET)

        pids_limit = d.pop("pids_limit", UNSET)

        _plugins = d.pop("plugins", UNSET)
        plugins: Union[Unset, PluginsInfo]
        if isinstance(_plugins, Unset):
            plugins = UNSET
        else:
            plugins = _plugins  # type: ignore[arg-type]

        product_license = d.pop("product_license", UNSET)

        _registry_config = d.pop("registry_config", UNSET)
        registry_config: Union[Unset, RegistryServiceConfig]
        if isinstance(_registry_config, Unset):
            registry_config = UNSET
        else:
            registry_config = _registry_config  # type: ignore[arg-type]

        _runc_commit = d.pop("runc_commit", UNSET)
        runc_commit: Union[Unset, Commit]
        if isinstance(_runc_commit, Unset):
            runc_commit = UNSET
        else:
            runc_commit = _runc_commit  # type: ignore[arg-type]

        runtimes = d.pop("runtimes", UNSET)
        security_options = cast(List[str], d.pop("security_options", UNSET))

        server_version = d.pop("server_version", UNSET)

        swap_limit = d.pop("swap_limit", UNSET)

        system_time = d.pop("system_time", UNSET)

        warnings = cast(List[str], d.pop("warnings", UNSET))

        docker_system_info = cls(
            architecture=architecture,
            bridge_nf_ip6tables=bridge_nf_ip6tables,
            bridge_nf_iptables=bridge_nf_iptables,
            cgroup_driver=cgroup_driver,
            cgroup_version=cgroup_version,
            cluster_advertise=cluster_advertise,
            cluster_store=cluster_store,
            containerd_commit=containerd_commit,
            containers=containers,
            containers_paused=containers_paused,
            containers_running=containers_running,
            containers_stopped=containers_stopped,
            cpu_cfs_period=cpu_cfs_period,
            cpu_cfs_quota=cpu_cfs_quota,
            cpu_set=cpu_set,
            cpu_shares=cpu_shares,
            debug=debug,
            default_address_pools=default_address_pools,
            default_runtime=default_runtime,
            docker_root_dir=docker_root_dir,
            driver=driver,
            driver_status=driver_status,
            experimental_build=experimental_build,
            http_proxy=http_proxy,
            https_proxy=https_proxy,
            id=id,
            images=images,
            index_server_address=index_server_address,
            init_binary=init_binary,
            init_commit=init_commit,
            ipv4_forwarding=ipv4_forwarding,
            isolation=isolation,
            kernel_memory=kernel_memory,
            kernel_memory_tcp=kernel_memory_tcp,
            kernel_version=kernel_version,
            labels=labels,
            live_restore_enabled=live_restore_enabled,
            logging_driver=logging_driver,
            mem_total=mem_total,
            memory_limit=memory_limit,
            n_events_listener=n_events_listener,
            n_fd=n_fd,
            ncpu=ncpu,
            no_proxy=no_proxy,
            oom_kill_disable=oom_kill_disable,
            operating_system=operating_system,
            os_type=os_type,
            os_version=os_version,
            pids_limit=pids_limit,
            plugins=plugins,
            product_license=product_license,
            registry_config=registry_config,
            runc_commit=runc_commit,
            runtimes=runtimes,
            security_options=security_options,
            server_version=server_version,
            swap_limit=swap_limit,
            system_time=system_time,
            warnings=warnings,
        )

        docker_system_info.additional_properties = d
        return docker_system_info

    @property

CR = TypeVar("CR", bound="EmailAuthenticationForm")

class EmailAuthenticationForm:
    """The body of the form for email authentication."""  # noqa: E501

    callback_url: Union[Unset, str] = UNSET

        callback_url = self.callback_url

        if callback_url is not UNSET:
            field_dict["callback_url"] = callback_url

    def from_dict(cls: Type[CR], src_dict: Dict[str, Any]) -> CR:
        callback_url = d.pop("callback_url", UNSET)

        email_authentication_form = cls(
        )

        email_authentication_form.additional_properties = d
        return email_authentication_form

    @property

from ..models.cache_metadata import CacheMetadata
from ..models.connection import Connection
from ..models.environment import Environment
from ..models.file_system_metadata import FileSystemMetadata

CE = TypeVar("CE", bound="EngineMetadata")

class EngineMetadata:
    """Metadata about our currently running server.

    async_jobs_running: Union[Unset, bool] = False
    cache: Union[Unset, CacheMetadata] = UNSET
    environment: Union[Unset, Environment] = UNSET
    fs: Union[Unset, FileSystemMetadata] = UNSET
    git_hash: Union[Unset, str] = UNSET
    pubsub: Union[Unset, Connection] = UNSET

        async_jobs_running = self.async_jobs_running
        if not isinstance(self.cache, Unset):
            cache = self.cache
        if not isinstance(self.environment, Unset):
            environment = self.environment
        if not isinstance(self.fs, Unset):
            fs = self.fs
        git_hash = self.git_hash
        if not isinstance(self.pubsub, Unset):
            pubsub = self.pubsub

        if async_jobs_running is not UNSET:
            field_dict["async_jobs_running"] = async_jobs_running
        if cache is not UNSET:
            field_dict["cache"] = cache
        if environment is not UNSET:
            field_dict["environment"] = environment
        if fs is not UNSET:
            field_dict["fs"] = fs
        if git_hash is not UNSET:
            field_dict["git_hash"] = git_hash
        if pubsub is not UNSET:
            field_dict["pubsub"] = pubsub

    def from_dict(cls: Type[CE], src_dict: Dict[str, Any]) -> CE:
        async_jobs_running = d.pop("async_jobs_running", UNSET)

        _cache = d.pop("cache", UNSET)
        cache: Union[Unset, CacheMetadata]
        if isinstance(_cache, Unset):
            cache = UNSET
        else:
            cache = _cache  # type: ignore[arg-type]

        _environment = d.pop("environment", UNSET)
        environment: Union[Unset, Environment]
        if isinstance(_environment, Unset):
            environment = UNSET
        else:
            environment = _environment  # type: ignore[arg-type]

        _fs = d.pop("fs", UNSET)
        fs: Union[Unset, FileSystemMetadata]
        if isinstance(_fs, Unset):
            fs = UNSET
        else:
            fs = _fs  # type: ignore[arg-type]

        git_hash = d.pop("git_hash", UNSET)

        _pubsub = d.pop("pubsub", UNSET)
        pubsub: Union[Unset, Connection]
        if isinstance(_pubsub, Unset):
            pubsub = UNSET
        else:
            pubsub = _pubsub  # type: ignore[arg-type]

        engine_metadata = cls(
            async_jobs_running=async_jobs_running,
            cache=cache,
            environment=environment,
            fs=fs,
            git_hash=git_hash,
            pubsub=pubsub,
        )

        engine_metadata.additional_properties = d
        return engine_metadata

    @property

class EntityType(str, Enum):
    """The type of entity"""  # noqa: E501

    ENTITY = "entity"
    OBJECT = "object"
    PATH = "path"
    CURVE = "curve"
    SOLID2D = "solid2d"
    SOLID3D = "solid3d"
    EDGE = "edge"
    FACE = "face"

class Environment(str, Enum):
    """The environment the server is running in."""  # noqa: E501

    """# The development environment. This is for running locally. """  # noqa: E501
    DEVELOPMENT = "DEVELOPMENT"
    """# The preview environment. This is when PRs are created and a service is deployed for testing. """  # noqa: E501
    PREVIEW = "PREVIEW"
    """# The production environment. """  # noqa: E501
    PRODUCTION = "PRODUCTION"

MS = TypeVar("MS", bound="Error")

class Error:
    """Error information from a response."""  # noqa: E501

    error_code: Union[Unset, str] = UNSET
    message: Union[Unset, str] = UNSET
    request_id: Union[Unset, str] = UNSET

        error_code = self.error_code
        message = self.message
        request_id = self.request_id

        if error_code is not UNSET:
            field_dict["error_code"] = error_code
        if message is not UNSET:
            field_dict["message"] = message
        if request_id is not UNSET:
            field_dict["request_id"] = request_id

    def from_dict(cls: Type[MS], src_dict: Dict[str, Any]) -> MS:
        error_code = d.pop("error_code", UNSET)

        message = d.pop("message", UNSET)

        request_id = d.pop("request_id", UNSET)

        error = cls(
            error_code=error_code,
            message=message,
            request_id=request_id,
        )

        error.additional_properties = d
        return error

    @property

from ..models.docker_system_info import DockerSystemInfo

LT = TypeVar("LT", bound="ExecutorMetadata")

class ExecutorMetadata:

    docker_info: Union[Unset, DockerSystemInfo] = UNSET

        if not isinstance(self.docker_info, Unset):
            docker_info = self.docker_info

        if docker_info is not UNSET:
            field_dict["docker_info"] = docker_info

    def from_dict(cls: Type[LT], src_dict: Dict[str, Any]) -> LT:
        _docker_info = d.pop("docker_info", UNSET)
        docker_info: Union[Unset, DockerSystemInfo]
        if isinstance(_docker_info, Unset):
            docker_info = UNSET
        else:
            docker_info = _docker_info  # type: ignore[arg-type]

        else:

        executor_metadata = cls(
            docker_info=docker_info,
        )

        executor_metadata.additional_properties = d
        return executor_metadata

    @property

ED = TypeVar("ED", bound="ExportFile")

class ExportFile:
    """A file to be exported to the client."""  # noqa: E501

    contents: Union[Unset, str] = UNSET

        contents = self.contents

        if contents is not UNSET:
            field_dict["contents"] = contents

    def from_dict(cls: Type[ED], src_dict: Dict[str, Any]) -> ED:
        contents = d.pop("contents", UNSET)

        export_file = cls(
            contents=contents,
        )

        export_file.additional_properties = d
        return export_file

    @property

YY = TypeVar("YY", bound="ExtendedUser")

class ExtendedUser:
    """Extended user information.

    This is mostly used for internal purposes. It returns a mapping of the user's information, including that of our third party services we use for users: MailChimp, Stripe, and Front

    company: Union[Unset, str] = UNSET
    discord: Union[Unset, str] = UNSET
    email_verified: Union[Unset, datetime.datetime] = UNSET
    first_name: Union[Unset, str] = UNSET
    front_id: Union[Unset, str] = UNSET
    github: Union[Unset, str] = UNSET
    image: Union[Unset, str] = UNSET
    last_name: Union[Unset, str] = UNSET
    mailchimp_id: Union[Unset, str] = UNSET
    stripe_id: Union[Unset, str] = UNSET

        company = self.company
        discord = self.discord
        email_verified: Union[Unset, str] = UNSET
        if not isinstance(self.email_verified, Unset):
            email_verified = self.email_verified.isoformat()
        first_name = self.first_name
        front_id = self.front_id
        github = self.github
        image = self.image
        last_name = self.last_name
        mailchimp_id = self.mailchimp_id
        stripe_id = self.stripe_id

        if company is not UNSET:
            field_dict["company"] = company
        if discord is not UNSET:
            field_dict["discord"] = discord
        if email_verified is not UNSET:
            field_dict["email_verified"] = email_verified
        if first_name is not UNSET:
            field_dict["first_name"] = first_name
        if front_id is not UNSET:
            field_dict["front_id"] = front_id
        if github is not UNSET:
            field_dict["github"] = github
        if image is not UNSET:
            field_dict["image"] = image
        if last_name is not UNSET:
            field_dict["last_name"] = last_name
        if mailchimp_id is not UNSET:
            field_dict["mailchimp_id"] = mailchimp_id
        if stripe_id is not UNSET:
            field_dict["stripe_id"] = stripe_id

    def from_dict(cls: Type[YY], src_dict: Dict[str, Any]) -> YY:
        company = d.pop("company", UNSET)

        else:

        discord = d.pop("discord", UNSET)

        _email_verified = d.pop("email_verified", UNSET)
        email_verified: Union[Unset, datetime.datetime]
        if isinstance(_email_verified, Unset):
            email_verified = UNSET
        else:
            email_verified = isoparse(_email_verified)

        first_name = d.pop("first_name", UNSET)

        front_id = d.pop("front_id", UNSET)

        github = d.pop("github", UNSET)

        image = d.pop("image", UNSET)

        last_name = d.pop("last_name", UNSET)

        mailchimp_id = d.pop("mailchimp_id", UNSET)

        stripe_id = d.pop("stripe_id", UNSET)

        else:

        extended_user = cls(
            company=company,
            discord=discord,
            email_verified=email_verified,
            first_name=first_name,
            front_id=front_id,
            github=github,
            id=id,
            image=image,
            last_name=last_name,
            mailchimp_id=mailchimp_id,
            stripe_id=stripe_id,
        )

        extended_user.additional_properties = d
        return extended_user

    @property

DO = TypeVar("DO", bound="ExtendedUserResultsPage")

class ExtendedUserResultsPage:

    from ..models.extended_user import ExtendedUser

    items: Union[Unset, List[ExtendedUser]] = UNSET

        from ..models.extended_user import ExtendedUser

        items: Union[Unset, List[ExtendedUser]] = UNSET

    def from_dict(cls: Type[DO], src_dict: Dict[str, Any]) -> DO:

        items = cast(List[ExtendedUser], d.pop("items", UNSET))

        extended_user_results_page = cls(
        )

        extended_user_results_page.additional_properties = d
        return extended_user_results_page

    @property

FZ = TypeVar("FZ", bound="FileCenterOfMass")

    """A file center of mass result."""  # noqa: E501

    def from_dict(cls: Type[FZ], src_dict: Dict[str, Any]) -> FZ:
        else:

        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

GL = TypeVar("GL", bound="FileConversion")

    def from_dict(cls: Type[GL], src_dict: Dict[str, Any]) -> GL:
        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

NN = TypeVar("NN", bound="FileDensity")

    """A file density result."""  # noqa: E501

    def from_dict(cls: Type[NN], src_dict: Dict[str, Any]) -> NN:
        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

class FileExportFormat(str, Enum):
    """The valid types of output file formats."""  # noqa: E501

    """# glTF 2.0. We refer to this as glTF since that is how our customers refer to it, although by default it will be in binary format and thus technically (glb). """  # noqa: E501
    GLTF = "gltf"
    """# The OBJ file format. <https://en.wikipedia.org/wiki/Wavefront_.obj_file> It may or may not have an an attached material (mtl // mtllib) within the file, but we interact with it as if it does not. """  # noqa: E501
    OBJ = "obj"
    """# The PLY file format. <https://en.wikipedia.org/wiki/PLY_(file_format)> """  # noqa: E501
    PLY = "ply"
    """# The STEP file format. <https://en.wikipedia.org/wiki/ISO_10303-21> """  # noqa: E501
    STEP = "step"
    """# The STL file format. <https://en.wikipedia.org/wiki/STL_(file_format)> """  # noqa: E501
    STL = "stl"

class FileImportFormat(str, Enum):
    """The valid types of source file formats."""  # noqa: E501

    """# glTF 2.0. """  # noqa: E501
    OBJ = "obj"
    PLY = "ply"
    STL = "stl"

OH = TypeVar("OH", bound="FileMass")

    """A file mass result."""  # noqa: E501

    def from_dict(cls: Type[OH], src_dict: Dict[str, Any]) -> OH:
        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

VI = TypeVar("VI", bound="FileSurfaceArea")

    """A file surface area result."""  # noqa: E501

    def from_dict(cls: Type[VI], src_dict: Dict[str, Any]) -> VI:
        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

ET = TypeVar("ET", bound="FileSystemMetadata")

class FileSystemMetadata:
    """Metadata about our file system.

    def from_dict(cls: Type[ET], src_dict: Dict[str, Any]) -> ET:

        file_system_metadata = cls(
            ok=ok,
        )

        file_system_metadata.additional_properties = d
        return file_system_metadata

    @property

QF = TypeVar("QF", bound="FileVolume")

    """A file volume result."""  # noqa: E501

    def from_dict(cls: Type[QF], src_dict: Dict[str, Any]) -> QF:
        else:

        else:

            id = UNSET
        else:

        else:

        else:

        else:

        else:

        else:

            id=id,
        )

    @property

DI = TypeVar("DI", bound="Gateway")

class Gateway:
    """Gateway information."""  # noqa: E501

    def from_dict(cls: Type[DI], src_dict: Dict[str, Any]) -> DI:

        gateway = cls(
        )

        gateway.additional_properties = d
        return gateway

    @property

class ImageType(str, Enum):
    """An enumeration."""  # noqa: E501

    PNG = "png"
    JPG = "jpg"

OJ = TypeVar("OJ", bound="IndexInfo")

class IndexInfo:
    """IndexInfo contains information about a registry."""  # noqa: E501

    mirrors: Union[Unset, List[str]] = UNSET
    official: Union[Unset, bool] = False
    secure: Union[Unset, bool] = False

        mirrors: Union[Unset, List[str]] = UNSET
        if not isinstance(self.mirrors, Unset):
            mirrors = self.mirrors
        official = self.official
        secure = self.secure

        if mirrors is not UNSET:
            field_dict["mirrors"] = mirrors
        if official is not UNSET:
            field_dict["official"] = official
        if secure is not UNSET:
            field_dict["secure"] = secure

    def from_dict(cls: Type[OJ], src_dict: Dict[str, Any]) -> OJ:
        mirrors = cast(List[str], d.pop("mirrors", UNSET))

        official = d.pop("official", UNSET)

        secure = d.pop("secure", UNSET)

        index_info = cls(
            mirrors=mirrors,
            official=official,
            secure=secure,
        )

        index_info.additional_properties = d
        return index_info

    @property

from ..models.system import System

UF = TypeVar("UF", bound="gltf")

class gltf:
    """Binary glTF 2.0. We refer to this as glTF since that is how our customers refer to it, but this can also import binary glTF (glb)."""  # noqa: E501

    type: str = "gltf"

    def from_dict(cls: Type[UF], src_dict: Dict[str, Any]) -> UF:

        gltf = cls(
        )

        gltf.additional_properties = d
        return gltf

    @property

YF = TypeVar("YF", bound="step")

class step:
    """ISO 10303-21 (STEP) format."""  # noqa: E501

    type: str = "step"

    def from_dict(cls: Type[YF], src_dict: Dict[str, Any]) -> YF:

        step = cls(
        )

        step.additional_properties = d
        return step

    @property

PY = TypeVar("PY", bound="obj")

class obj:
    """Wavefront OBJ format."""  # noqa: E501

    coords: Union[Unset, System] = UNSET
    type: str = "obj"
    units: Union[Unset, UnitLength] = UNSET

        if not isinstance(self.coords, Unset):
            coords = self.coords
        if not isinstance(self.units, Unset):
            units = self.units

        if coords is not UNSET:
            field_dict["coords"] = coords
        if units is not UNSET:
            field_dict["units"] = units

    def from_dict(cls: Type[PY], src_dict: Dict[str, Any]) -> PY:
        _coords = d.pop("coords", UNSET)
        coords: Union[Unset, System]
        if isinstance(_coords, Unset):
            coords = UNSET
        else:
            coords = _coords  # type: ignore[arg-type]

        _units = d.pop("units", UNSET)
        units: Union[Unset, UnitLength]
        if isinstance(_units, Unset):
            units = UNSET
        else:
            units = _units  # type: ignore[arg-type]

        obj = cls(
            coords=coords,
            units=units,
        )

        obj.additional_properties = d
        return obj

    @property

LK = TypeVar("LK", bound="ply")

class ply:
    """The PLY Polygon File Format."""  # noqa: E501

    type: str = "ply"

    def from_dict(cls: Type[LK], src_dict: Dict[str, Any]) -> LK:
        else:

        else:

        ply = cls(
        )

        ply.additional_properties = d
        return ply

    @property

AR = TypeVar("AR", bound="stl")

class stl:
    """*ST**ereo**L**ithography format."""  # noqa: E501

    type: str = "stl"

    def from_dict(cls: Type[AR], src_dict: Dict[str, Any]) -> AR:
        else:

        else:

        stl = cls(
        )

        stl.additional_properties = d
        return stl

    @property

InputFormat = Union[gltf, step, obj, ply, stl]

from ..models.invoice_status import InvoiceStatus

WB = TypeVar("WB", bound="Invoice")

class Invoice:
    """An invoice."""  # noqa: E501

    amount_due: Union[Unset, float] = UNSET
    amount_paid: Union[Unset, float] = UNSET
    amount_remaining: Union[Unset, float] = UNSET
    attempt_count: Union[Unset, int] = UNSET
    attempted: Union[Unset, bool] = False
    customer_email: Union[Unset, str] = UNSET
    customer_id: Union[Unset, str] = UNSET
    default_payment_method: Union[Unset, str] = UNSET
    description: Union[Unset, str] = UNSET
    from ..models.discount import Discount

    discounts: Union[Unset, List[Discount]] = UNSET
    from ..models.invoice_line_item import InvoiceLineItem

    lines: Union[Unset, List[InvoiceLineItem]] = UNSET
    number: Union[Unset, str] = UNSET
    paid: Union[Unset, bool] = False
    pdf: Union[Unset, str] = UNSET
    receipt_number: Union[Unset, str] = UNSET
    statement_descriptor: Union[Unset, str] = UNSET
    status: Union[Unset, InvoiceStatus] = UNSET
    subtotal: Union[Unset, float] = UNSET
    tax: Union[Unset, float] = UNSET
    total: Union[Unset, float] = UNSET

        amount_due = self.amount_due
        amount_paid = self.amount_paid
        amount_remaining = self.amount_remaining
        attempt_count = self.attempt_count
        attempted = self.attempted
        customer_email = self.customer_email
        customer_id = self.customer_id
        default_payment_method = self.default_payment_method
        description = self.description
        from ..models.discount import Discount

        discounts: Union[Unset, List[Discount]] = UNSET
        if not isinstance(self.discounts, Unset):
            discounts = self.discounts
        from ..models.invoice_line_item import InvoiceLineItem

        lines: Union[Unset, List[InvoiceLineItem]] = UNSET
        if not isinstance(self.lines, Unset):
            lines = self.lines
        number = self.number
        paid = self.paid
        pdf = self.pdf
        receipt_number = self.receipt_number
        statement_descriptor = self.statement_descriptor
        subtotal = self.subtotal
        tax = self.tax
        total = self.total

        if amount_due is not UNSET:
            field_dict["amount_due"] = amount_due
        if amount_paid is not UNSET:
            field_dict["amount_paid"] = amount_paid
        if amount_remaining is not UNSET:
            field_dict["amount_remaining"] = amount_remaining
        if attempt_count is not UNSET:
            field_dict["attempt_count"] = attempt_count
        if attempted is not UNSET:
            field_dict["attempted"] = attempted
        if customer_email is not UNSET:
            field_dict["customer_email"] = customer_email
        if customer_id is not UNSET:
            field_dict["customer_id"] = customer_id
        if default_payment_method is not UNSET:
            field_dict["default_payment_method"] = default_payment_method
        if description is not UNSET:
            field_dict["description"] = description
        if discounts is not UNSET:
            field_dict["discounts"] = discounts
        if lines is not UNSET:
            field_dict["lines"] = lines
        if number is not UNSET:
            field_dict["number"] = number
        if paid is not UNSET:
            field_dict["paid"] = paid
        if pdf is not UNSET:
            field_dict["pdf"] = pdf
        if receipt_number is not UNSET:
            field_dict["receipt_number"] = receipt_number
        if statement_descriptor is not UNSET:
            field_dict["statement_descriptor"] = statement_descriptor
        if subtotal is not UNSET:
            field_dict["subtotal"] = subtotal
        if tax is not UNSET:
            field_dict["tax"] = tax
        if total is not UNSET:
            field_dict["total"] = total

    def from_dict(cls: Type[WB], src_dict: Dict[str, Any]) -> WB:
        amount_due = d.pop("amount_due", UNSET)

        amount_paid = d.pop("amount_paid", UNSET)

        amount_remaining = d.pop("amount_remaining", UNSET)

        attempt_count = d.pop("attempt_count", UNSET)

        attempted = d.pop("attempted", UNSET)

        else:

        else:

        customer_email = d.pop("customer_email", UNSET)

        customer_id = d.pop("customer_id", UNSET)

        default_payment_method = d.pop("default_payment_method", UNSET)

        description = d.pop("description", UNSET)

        discounts = cast(List[Discount], d.pop("discounts", UNSET))

        lines = cast(List[InvoiceLineItem], d.pop("lines", UNSET))

        number = d.pop("number", UNSET)

        paid = d.pop("paid", UNSET)

        pdf = d.pop("pdf", UNSET)

        receipt_number = d.pop("receipt_number", UNSET)

        statement_descriptor = d.pop("statement_descriptor", UNSET)

        status: Union[Unset, InvoiceStatus]
        else:

        subtotal = d.pop("subtotal", UNSET)

        tax = d.pop("tax", UNSET)

        total = d.pop("total", UNSET)

        invoice = cls(
            amount_due=amount_due,
            amount_paid=amount_paid,
            amount_remaining=amount_remaining,
            attempt_count=attempt_count,
            attempted=attempted,
            customer_email=customer_email,
            customer_id=customer_id,
            default_payment_method=default_payment_method,
            description=description,
            discounts=discounts,
            id=id,
            lines=lines,
            number=number,
            paid=paid,
            pdf=pdf,
            receipt_number=receipt_number,
            statement_descriptor=statement_descriptor,
            subtotal=subtotal,
            tax=tax,
            total=total,
            url=url,
        )

        invoice.additional_properties = d
        return invoice

    @property

KK = TypeVar("KK", bound="InvoiceLineItem")

class InvoiceLineItem:
    """An invoice line item."""  # noqa: E501

    amount: Union[Unset, float] = UNSET
    invoice_item: Union[Unset, str] = UNSET

        amount = self.amount
        invoice_item = self.invoice_item

        if amount is not UNSET:
            field_dict["amount"] = amount
        if invoice_item is not UNSET:
            field_dict["invoice_item"] = invoice_item

    def from_dict(cls: Type[KK], src_dict: Dict[str, Any]) -> KK:
        amount = d.pop("amount", UNSET)

        else:

        invoice_item = d.pop("invoice_item", UNSET)

        invoice_line_item = cls(
            amount=amount,
            id=id,
            invoice_item=invoice_item,
        )

        invoice_line_item.additional_properties = d
        return invoice_line_item

    @property

class InvoiceStatus(str, Enum):
    """An enum representing the possible values of an `Invoice`'s `status` field."""  # noqa: E501

    """# Deleted. """  # noqa: E501
    DELETED = "deleted"
    """# Draft. """  # noqa: E501
    DRAFT = "draft"
    """# Open. """  # noqa: E501
    OPEN = "open"
    """# Paid. """  # noqa: E501
    PAID = "paid"
    """# Uncollectible. """  # noqa: E501
    UNCOLLECTIBLE = "uncollectible"
    """# Void. """  # noqa: E501
    VOID = "void"

from ..models.jetstream_config import JetstreamConfig
from ..models.jetstream_stats import JetstreamStats
from ..models.meta_cluster_info import MetaClusterInfo

HC = TypeVar("HC", bound="Jetstream")

class Jetstream:
    """Jetstream information."""  # noqa: E501

    config: Union[Unset, JetstreamConfig] = UNSET
    meta: Union[Unset, MetaClusterInfo] = UNSET
    stats: Union[Unset, JetstreamStats] = UNSET

        if not isinstance(self.config, Unset):
            config = self.config
        if not isinstance(self.meta, Unset):
            meta = self.meta
        if not isinstance(self.stats, Unset):
            stats = self.stats

        if config is not UNSET:
            field_dict["config"] = config
        if meta is not UNSET:
            field_dict["meta"] = meta
        if stats is not UNSET:
            field_dict["stats"] = stats

    def from_dict(cls: Type[HC], src_dict: Dict[str, Any]) -> HC:
        _config = d.pop("config", UNSET)
        config: Union[Unset, JetstreamConfig]
        if isinstance(_config, Unset):
            config = UNSET
        else:
            config = _config  # type: ignore[arg-type]

        _meta = d.pop("meta", UNSET)
        meta: Union[Unset, MetaClusterInfo]
        if isinstance(_meta, Unset):
            meta = UNSET
        else:
            meta = _meta  # type: ignore[arg-type]

        _stats = d.pop("stats", UNSET)
        stats: Union[Unset, JetstreamStats]
        if isinstance(_stats, Unset):
            stats = UNSET
        else:
            stats = _stats  # type: ignore[arg-type]

        jetstream = cls(
            config=config,
            meta=meta,
            stats=stats,
        )

        jetstream.additional_properties = d
        return jetstream

    @property

FM = TypeVar("FM", bound="JetstreamApiStats")

class JetstreamApiStats:
    """Jetstream API statistics."""  # noqa: E501

    errors: Union[Unset, int] = UNSET
    inflight: Union[Unset, int] = UNSET
    total: Union[Unset, int] = UNSET

        errors = self.errors
        inflight = self.inflight

        if errors is not UNSET:
            field_dict["errors"] = errors
        if inflight is not UNSET:
            field_dict["inflight"] = inflight

    def from_dict(cls: Type[FM], src_dict: Dict[str, Any]) -> FM:
        errors = d.pop("errors", UNSET)

        inflight = d.pop("inflight", UNSET)

        jetstream_api_stats = cls(
            errors=errors,
            inflight=inflight,
        )

        jetstream_api_stats.additional_properties = d
        return jetstream_api_stats

    @property

PV = TypeVar("PV", bound="JetstreamConfig")

class JetstreamConfig:
    """Jetstream configuration."""  # noqa: E501

    domain: Union[Unset, str] = UNSET
    max_memory: Union[Unset, int] = UNSET
    max_storage: Union[Unset, int] = UNSET
    store_dir: Union[Unset, str] = UNSET

        domain = self.domain
        max_memory = self.max_memory
        max_storage = self.max_storage
        store_dir = self.store_dir

        if domain is not UNSET:
            field_dict["domain"] = domain
        if max_memory is not UNSET:
            field_dict["max_memory"] = max_memory
        if max_storage is not UNSET:
            field_dict["max_storage"] = max_storage
        if store_dir is not UNSET:
            field_dict["store_dir"] = store_dir

    def from_dict(cls: Type[PV], src_dict: Dict[str, Any]) -> PV:
        domain = d.pop("domain", UNSET)

        max_memory = d.pop("max_memory", UNSET)

        max_storage = d.pop("max_storage", UNSET)

        store_dir = d.pop("store_dir", UNSET)

        jetstream_config = cls(
            domain=domain,
            max_memory=max_memory,
            max_storage=max_storage,
            store_dir=store_dir,
        )

        jetstream_config.additional_properties = d
        return jetstream_config

    @property

from ..models.jetstream_api_stats import JetstreamApiStats

QI = TypeVar("QI", bound="JetstreamStats")

class JetstreamStats:
    """Jetstream statistics."""  # noqa: E501

    accounts: Union[Unset, int] = UNSET
    api: Union[Unset, JetstreamApiStats] = UNSET
    ha_assets: Union[Unset, int] = UNSET
    memory: Union[Unset, int] = UNSET
    reserved_memory: Union[Unset, int] = UNSET
    reserved_store: Union[Unset, int] = UNSET
    store: Union[Unset, int] = UNSET

        accounts = self.accounts
        ha_assets = self.ha_assets
        memory = self.memory
        reserved_memory = self.reserved_memory
        reserved_store = self.reserved_store
        store = self.store

        if accounts is not UNSET:
            field_dict["accounts"] = accounts
        if ha_assets is not UNSET:
            field_dict["ha_assets"] = ha_assets
        if memory is not UNSET:
            field_dict["memory"] = memory
        if reserved_memory is not UNSET:
            field_dict["reserved_memory"] = reserved_memory
        if reserved_store is not UNSET:
            field_dict["reserved_store"] = reserved_store
        if store is not UNSET:
            field_dict["store"] = store

    def from_dict(cls: Type[QI], src_dict: Dict[str, Any]) -> QI:
        accounts = d.pop("accounts", UNSET)

        api: Union[Unset, JetstreamApiStats]
            api = UNSET
        else:

        ha_assets = d.pop("ha_assets", UNSET)

        memory = d.pop("memory", UNSET)

        reserved_memory = d.pop("reserved_memory", UNSET)

        reserved_store = d.pop("reserved_store", UNSET)

        store = d.pop("store", UNSET)

        jetstream_stats = cls(
            accounts=accounts,
            api=api,
            ha_assets=ha_assets,
            memory=memory,
            reserved_memory=reserved_memory,
            reserved_store=reserved_store,
            store=store,
        )

        jetstream_stats.additional_properties = d
        return jetstream_stats

    @property

TP = TypeVar("TP", bound="LeafNode")

class LeafNode:
    """Leaf node information."""  # noqa: E501

    def from_dict(cls: Type[TP], src_dict: Dict[str, Any]) -> TP:

        leaf_node = cls(
        )

        leaf_node.additional_properties = d
        return leaf_node

    @property

CF = TypeVar("CF", bound="Mesh")

class Mesh:
    mesh: Union[Unset, str] = UNSET

        mesh = self.mesh

        if mesh is not UNSET:
            field_dict["mesh"] = mesh

    def from_dict(cls: Type[CF], src_dict: Dict[str, Any]) -> CF:
        mesh = d.pop("mesh", UNSET)

        mesh = cls(
            mesh=mesh,
        )

        mesh.additional_properties = d
        return mesh

    @property

OM = TypeVar("OM", bound="MetaClusterInfo")

class MetaClusterInfo:

    cluster_size: Union[Unset, int] = UNSET
    leader: Union[Unset, str] = UNSET

        cluster_size = self.cluster_size
        leader = self.leader

        if cluster_size is not UNSET:
            field_dict["cluster_size"] = cluster_size
        if leader is not UNSET:
            field_dict["leader"] = leader

    def from_dict(cls: Type[OM], src_dict: Dict[str, Any]) -> OM:
        cluster_size = d.pop("cluster_size", UNSET)

        leader = d.pop("leader", UNSET)

        meta_cluster_info = cls(
            cluster_size=cluster_size,
            leader=leader,
        )

        meta_cluster_info.additional_properties = d
        return meta_cluster_info

    @property

from ..models.engine_metadata import EngineMetadata
from ..models.executor_metadata import ExecutorMetadata
from ..models.point_e_metadata import PointEMetadata

EN = TypeVar("EN", bound="Metadata")

class Metadata:

    engine: Union[Unset, EngineMetadata] = UNSET
    executor: Union[Unset, ExecutorMetadata] = UNSET
    point_e: Union[Unset, PointEMetadata] = UNSET

        if not isinstance(self.engine, Unset):
            engine = self.engine
        if not isinstance(self.executor, Unset):
            executor = self.executor
        if not isinstance(self.point_e, Unset):
            point_e = self.point_e

        if engine is not UNSET:
            field_dict["engine"] = engine
        if executor is not UNSET:
            field_dict["executor"] = executor
        if point_e is not UNSET:
            field_dict["point_e"] = point_e

    def from_dict(cls: Type[EN], src_dict: Dict[str, Any]) -> EN:
        else:

        _engine = d.pop("engine", UNSET)
        engine: Union[Unset, EngineMetadata]
        if isinstance(_engine, Unset):
            engine = UNSET
        else:
            engine = _engine  # type: ignore[arg-type]

        else:

        _executor = d.pop("executor", UNSET)
        executor: Union[Unset, ExecutorMetadata]
        if isinstance(_executor, Unset):
            executor = UNSET
        else:
            executor = _executor  # type: ignore[arg-type]

            fs = UNSET
        else:

        _point_e = d.pop("point_e", UNSET)
        point_e: Union[Unset, PointEMetadata]
        if isinstance(_point_e, Unset):
            point_e = UNSET
        else:
            point_e = _point_e  # type: ignore[arg-type]

        else:

        metadata = cls(
            engine=engine,
            executor=executor,
            fs=fs,
            point_e=point_e,
        )

        metadata.additional_properties = d
        return metadata

    @property

class Method(str, Enum):
    """The Request Method (VERB)

    This type also contains constants for a number of common HTTP methods such as GET, POST, etc.

    Currently includes 8 variants representing the 8 methods defined in [RFC 7230](https://tools.ietf.org/html/rfc7231#section-4.1), plus PATCH, and an Extension variant for all extensions.

    """# The `OPTIONS` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.2.1). """  # noqa: E501
    OPTIONS = "OPTIONS"
    """# The `GET` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1). """  # noqa: E501
    GET = "GET"
    """# The `POST` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1). """  # noqa: E501
    POST = "POST"
    """# The `PUT` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.1). """  # noqa: E501
    PUT = "PUT"
    """# The `DELETE` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.5). """  # noqa: E501
    DELETE = "DELETE"
    """# The `HEAD` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.2). """  # noqa: E501
    HEAD = "HEAD"
    """# The `TRACE` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3). """  # noqa: E501
    TRACE = "TRACE"
    """# The `CONNECT` method as defined in [RFC 7231](https://tools.ietf.org/html/rfc7231#section-4.3.6). """  # noqa: E501
    CONNECT = "CONNECT"
    """# The `PATCH` method as defined in [RFC 5789](https://tools.ietf.org/html/rfc5789). """  # noqa: E501
    PATCH = "PATCH"
    """# A catch all. """  # noqa: E501
    EXTENSION = "EXTENSION"

from ..models.annotation_options import AnnotationOptions
from ..models.annotation_type import AnnotationType
from ..models.camera_drag_interaction_type import CameraDragInteractionType
from ..models.modeling_cmd_id import ModelingCmdId
from ..models.path_segment import PathSegment
from ..models.point2d import Point2d
from ..models.scene_selection_type import SceneSelectionType

RS = TypeVar("RS", bound="start_path")

class start_path:
    """Start a path."""  # noqa: E501

    type: str = "start_path"

    def from_dict(cls: Type[RS], src_dict: Dict[str, Any]) -> RS:

        start_path = cls(
        )

        start_path.additional_properties = d
        return start_path

    @property

LR = TypeVar("LR", bound="move_path_pen")

class move_path_pen:
    """Move the path's "pen"."""  # noqa: E501

    path: Union[Unset, ModelingCmdId] = UNSET
    to: Union[Unset, Point3d] = UNSET
    type: str = "move_path_pen"

        if not isinstance(self.path, Unset):
            path = self.path
        if not isinstance(self.to, Unset):
            to = self.to

        if path is not UNSET:
            field_dict["path"] = path
        if to is not UNSET:
            field_dict["to"] = to

    def from_dict(cls: Type[LR], src_dict: Dict[str, Any]) -> LR:
        _path = d.pop("path", UNSET)
        path: Union[Unset, ModelingCmdId]
        if isinstance(_path, Unset):
            path = UNSET
        else:
            path = _path  # type: ignore[arg-type]

        _to = d.pop("to", UNSET)
        to: Union[Unset, Point3d]
        if isinstance(_to, Unset):
            to = UNSET
        else:
            to = _to  # type: ignore[arg-type]

        move_path_pen = cls(
            path=path,
            to=to,
        )

        move_path_pen.additional_properties = d
        return move_path_pen

    @property

MP = TypeVar("MP", bound="extend_path")

class extend_path:
    """Extend a path by adding a new segment which starts at the path's "pen". If no "pen" location has been set before (via `MovePen`), then the pen is at the origin."""  # noqa: E501

    segment: Union[Unset, PathSegment] = UNSET
    type: str = "extend_path"

        if not isinstance(self.segment, Unset):
            segment = self.segment

        if segment is not UNSET:
            field_dict["segment"] = segment

    def from_dict(cls: Type[MP], src_dict: Dict[str, Any]) -> MP:
        else:

        _segment = d.pop("segment", UNSET)
        segment: Union[Unset, PathSegment]
        if isinstance(_segment, Unset):
            segment = UNSET
        else:
            segment = _segment  # type: ignore[arg-type]

        extend_path = cls(
            segment=segment,
        )

        extend_path.additional_properties = d
        return extend_path

    @property

WF = TypeVar("WF", bound="extrude")

class extrude:
    """Extrude a 2D solid."""  # noqa: E501

    cap: Union[Unset, bool] = False
    distance: Union[Unset, float] = UNSET
    target: Union[Unset, ModelingCmdId] = UNSET
    type: str = "extrude"

        cap = self.cap
        distance = self.distance
        if not isinstance(self.target, Unset):
            target = self.target

        if cap is not UNSET:
            field_dict["cap"] = cap
        if distance is not UNSET:
            field_dict["distance"] = distance
        if target is not UNSET:
            field_dict["target"] = target

    def from_dict(cls: Type[WF], src_dict: Dict[str, Any]) -> WF:
        cap = d.pop("cap", UNSET)

        distance = d.pop("distance", UNSET)

        _target = d.pop("target", UNSET)
        target: Union[Unset, ModelingCmdId]
        if isinstance(_target, Unset):
            target = UNSET
        else:
            target = _target  # type: ignore[arg-type]

        extrude = cls(
            cap=cap,
            distance=distance,
            target=target,
        )

        extrude.additional_properties = d
        return extrude

    @property

RO = TypeVar("RO", bound="close_path")

class close_path:
    """Closes a path, converting it to a 2D solid."""  # noqa: E501

    path_id: Union[Unset, str] = UNSET
    type: str = "close_path"

        path_id = self.path_id

        if path_id is not UNSET:
            field_dict["path_id"] = path_id

    def from_dict(cls: Type[RO], src_dict: Dict[str, Any]) -> RO:
        path_id = d.pop("path_id", UNSET)

        close_path = cls(
            path_id=path_id,
        )

        close_path.additional_properties = d
        return close_path

    @property

DN = TypeVar("DN", bound="camera_drag_start")

class camera_drag_start:
    """Camera drag started."""  # noqa: E501

    interaction: Union[Unset, CameraDragInteractionType] = UNSET
    type: str = "camera_drag_start"
    window: Union[Unset, Point2d] = UNSET

        if not isinstance(self.interaction, Unset):
            interaction = self.interaction
        if not isinstance(self.window, Unset):
            window = self.window

        if interaction is not UNSET:
            field_dict["interaction"] = interaction
        if window is not UNSET:
            field_dict["window"] = window

    def from_dict(cls: Type[DN], src_dict: Dict[str, Any]) -> DN:
        _interaction = d.pop("interaction", UNSET)
        interaction: Union[Unset, CameraDragInteractionType]
        if isinstance(_interaction, Unset):
            interaction = UNSET
        else:
            interaction = _interaction  # type: ignore[arg-type]

        _window = d.pop("window", UNSET)
        window: Union[Unset, Point2d]
        if isinstance(_window, Unset):
            window = UNSET
        else:
            window = _window  # type: ignore[arg-type]

        camera_drag_start = cls(
            interaction=interaction,
            window=window,
        )

        camera_drag_start.additional_properties = d
        return camera_drag_start

    @property

BA = TypeVar("BA", bound="camera_drag_move")

class camera_drag_move:
    """Camera drag continued."""  # noqa: E501

    sequence: Union[Unset, int] = UNSET
    type: str = "camera_drag_move"

        sequence = self.sequence

        if sequence is not UNSET:
            field_dict["sequence"] = sequence

    def from_dict(cls: Type[BA], src_dict: Dict[str, Any]) -> BA:
        else:

        sequence = d.pop("sequence", UNSET)

        else:

        camera_drag_move = cls(
            sequence=sequence,
        )

        camera_drag_move.additional_properties = d
        return camera_drag_move

    @property

OR = TypeVar("OR", bound="camera_drag_end")

class camera_drag_end:
    """Camera drag ended."""  # noqa: E501

    type: str = "camera_drag_end"

    def from_dict(cls: Type[OR], src_dict: Dict[str, Any]) -> OR:
        else:

        else:

        camera_drag_end = cls(
        )

        camera_drag_end.additional_properties = d
        return camera_drag_end

    @property

CB = TypeVar("CB", bound="default_camera_look_at")

class default_camera_look_at:
    """Change what the default camera is looking at."""  # noqa: E501

    center: Union[Unset, Point3d] = UNSET
    type: str = "default_camera_look_at"
    up: Union[Unset, Point3d] = UNSET
    vantage: Union[Unset, Point3d] = UNSET

        if not isinstance(self.center, Unset):
            center = self.center
        if not isinstance(self.up, Unset):
            up = self.up
        if not isinstance(self.vantage, Unset):
            vantage = self.vantage

        if center is not UNSET:
            field_dict["center"] = center
        if up is not UNSET:
            field_dict["up"] = up
        if vantage is not UNSET:
            field_dict["vantage"] = vantage

    def from_dict(cls: Type[CB], src_dict: Dict[str, Any]) -> CB:
        _center = d.pop("center", UNSET)
        center: Union[Unset, Point3d]
        if isinstance(_center, Unset):
            center = UNSET
        else:
            center = _center  # type: ignore[arg-type]

        _up = d.pop("up", UNSET)
        up: Union[Unset, Point3d]
        if isinstance(_up, Unset):
            up = UNSET
        else:
            up = _up  # type: ignore[arg-type]

        _vantage = d.pop("vantage", UNSET)
        vantage: Union[Unset, Point3d]
        if isinstance(_vantage, Unset):
            vantage = UNSET
        else:
            vantage = _vantage  # type: ignore[arg-type]

        default_camera_look_at = cls(
            center=center,
            up=up,
            vantage=vantage,
        )

        default_camera_look_at.additional_properties = d
        return default_camera_look_at

    @property

LC = TypeVar("LC", bound="default_camera_enable_sketch_mode")

class default_camera_enable_sketch_mode:
    """Enable sketch mode, where users can sketch 2D geometry. Users choose a plane to sketch on."""  # noqa: E501

    animated: Union[Unset, bool] = False
    distance_to_plane: Union[Unset, float] = UNSET
    origin: Union[Unset, Point3d] = UNSET
    ortho: Union[Unset, bool] = False
    type: str = "default_camera_enable_sketch_mode"
    x_axis: Union[Unset, Point3d] = UNSET
    y_axis: Union[Unset, Point3d] = UNSET

        animated = self.animated
        distance_to_plane = self.distance_to_plane
        if not isinstance(self.origin, Unset):
            origin = self.origin
        ortho = self.ortho
        if not isinstance(self.x_axis, Unset):
            x_axis = self.x_axis
        if not isinstance(self.y_axis, Unset):
            y_axis = self.y_axis

        if animated is not UNSET:
            field_dict["animated"] = animated
        if distance_to_plane is not UNSET:
            field_dict["distance_to_plane"] = distance_to_plane
        if ortho is not UNSET:
            field_dict["ortho"] = ortho
        if x_axis is not UNSET:
            field_dict["x_axis"] = x_axis
        if y_axis is not UNSET:
            field_dict["y_axis"] = y_axis

    def from_dict(cls: Type[LC], src_dict: Dict[str, Any]) -> LC:
        animated = d.pop("animated", UNSET)

        distance_to_plane = d.pop("distance_to_plane", UNSET)

        _origin = d.pop("origin", UNSET)
        origin: Union[Unset, Point3d]
        if isinstance(_origin, Unset):
            origin = UNSET
        else:
            origin = _origin  # type: ignore[arg-type]

        ortho = d.pop("ortho", UNSET)

        _x_axis = d.pop("x_axis", UNSET)
        x_axis: Union[Unset, Point3d]
        if isinstance(_x_axis, Unset):
            x_axis = UNSET
        else:
            x_axis = _x_axis  # type: ignore[arg-type]

        _y_axis = d.pop("y_axis", UNSET)
        y_axis: Union[Unset, Point3d]
        if isinstance(_y_axis, Unset):
            y_axis = UNSET
        else:
            y_axis = _y_axis  # type: ignore[arg-type]

        default_camera_enable_sketch_mode = cls(
            animated=animated,
            distance_to_plane=distance_to_plane,
            ortho=ortho,
            x_axis=x_axis,
            y_axis=y_axis,
        )

        default_camera_enable_sketch_mode.additional_properties = d
        return default_camera_enable_sketch_mode

    @property

TO = TypeVar("TO", bound="default_camera_disable_sketch_mode")

class default_camera_disable_sketch_mode:
    """Disable sketch mode, from the default camera."""  # noqa: E501

    type: str = "default_camera_disable_sketch_mode"

    def from_dict(cls: Type[TO], src_dict: Dict[str, Any]) -> TO:

        default_camera_disable_sketch_mode = cls(
        )

        default_camera_disable_sketch_mode.additional_properties = d
        return default_camera_disable_sketch_mode

    @property

ZP = TypeVar("ZP", bound="export")

class export:
    """Export the scene to a file."""  # noqa: E501

    entity_ids: Union[Unset, List[str]] = UNSET
    format: Union[Unset, OutputFormat] = UNSET
    type: str = "export"

        entity_ids: Union[Unset, List[str]] = UNSET
        if not isinstance(self.entity_ids, Unset):
            entity_ids = self.entity_ids
        if not isinstance(self.format, Unset):
            format = self.format

        if entity_ids is not UNSET:
            field_dict["entity_ids"] = entity_ids
        if format is not UNSET:
            field_dict["format"] = format

    def from_dict(cls: Type[ZP], src_dict: Dict[str, Any]) -> ZP:
        entity_ids = cast(List[str], d.pop("entity_ids", UNSET))

        _format = d.pop("format", UNSET)
        format: Union[Unset, OutputFormat]
        if isinstance(_format, Unset):
            format = UNSET
        else:
            format = _format  # type: ignore[arg-type]

        export = cls(
            entity_ids=entity_ids,
            format=format,
        )

        export.additional_properties = d
        return export

    @property

EO = TypeVar("EO", bound="entity_get_parent_id")

class entity_get_parent_id:
    """What is this entity's parent?"""  # noqa: E501

    entity_id: Union[Unset, str] = UNSET
    type: str = "entity_get_parent_id"

        entity_id = self.entity_id

        if entity_id is not UNSET:
            field_dict["entity_id"] = entity_id

    def from_dict(cls: Type[EO], src_dict: Dict[str, Any]) -> EO:
        entity_id = d.pop("entity_id", UNSET)

        entity_get_parent_id = cls(
            entity_id=entity_id,
        )

        entity_get_parent_id.additional_properties = d
        return entity_get_parent_id

    @property

NY = TypeVar("NY", bound="entity_get_num_children")

class entity_get_num_children:
    """How many children does the entity have?"""  # noqa: E501

    type: str = "entity_get_num_children"

    def from_dict(cls: Type[NY], src_dict: Dict[str, Any]) -> NY:

        entity_get_num_children = cls(
        )

        entity_get_num_children.additional_properties = d
        return entity_get_num_children

    @property

QO = TypeVar("QO", bound="entity_get_child_uuid")

class entity_get_child_uuid:
    """What is the UUID of this entity's n-th child?"""  # noqa: E501

    child_index: Union[Unset, int] = UNSET
    type: str = "entity_get_child_uuid"

        child_index = self.child_index

        if child_index is not UNSET:
            field_dict["child_index"] = child_index

    def from_dict(cls: Type[QO], src_dict: Dict[str, Any]) -> QO:
        child_index = d.pop("child_index", UNSET)

        entity_get_child_uuid = cls(
            child_index=child_index,
        )

        entity_get_child_uuid.additional_properties = d
        return entity_get_child_uuid

    @property

KX = TypeVar("KX", bound="entity_get_all_child_uuids")

class entity_get_all_child_uuids:
    """What are all UUIDs of this entity's children?"""  # noqa: E501

    type: str = "entity_get_all_child_uuids"

    def from_dict(cls: Type[KX], src_dict: Dict[str, Any]) -> KX:

        entity_get_all_child_uuids = cls(
        )

        entity_get_all_child_uuids.additional_properties = d
        return entity_get_all_child_uuids

    @property

IZ = TypeVar("IZ", bound="edit_mode_enter")

class edit_mode_enter:
    """Enter edit mode"""  # noqa: E501

    target: Union[Unset, str] = UNSET
    type: str = "edit_mode_enter"

        target = self.target

    def from_dict(cls: Type[IZ], src_dict: Dict[str, Any]) -> IZ:
        target = d.pop("target", UNSET)

        edit_mode_enter = cls(
        )

        edit_mode_enter.additional_properties = d
        return edit_mode_enter

    @property

WO = TypeVar("WO", bound="edit_mode_exit")

class edit_mode_exit:
    """Exit edit mode"""  # noqa: E501

    type: str = "edit_mode_exit"

    def from_dict(cls: Type[WO], src_dict: Dict[str, Any]) -> WO:

        edit_mode_exit = cls(
        )

        edit_mode_exit.additional_properties = d
        return edit_mode_exit

    @property

NK = TypeVar("NK", bound="select_with_point")

class select_with_point:
    """Modifies the selection by simulating a "mouse click" at the given x,y window coordinate Returns ID of whatever was selected."""  # noqa: E501

    selected_at_window: Union[Unset, Point2d] = UNSET
    selection_type: Union[Unset, SceneSelectionType] = UNSET
    type: str = "select_with_point"

        if not isinstance(self.selected_at_window, Unset):
            selected_at_window = self.selected_at_window
        if not isinstance(self.selection_type, Unset):
            selection_type = self.selection_type

        if selected_at_window is not UNSET:
            field_dict["selected_at_window"] = selected_at_window
        if selection_type is not UNSET:
            field_dict["selection_type"] = selection_type

    def from_dict(cls: Type[NK], src_dict: Dict[str, Any]) -> NK:
        _selected_at_window = d.pop("selected_at_window", UNSET)
        selected_at_window: Union[Unset, Point2d]
        if isinstance(_selected_at_window, Unset):
            selected_at_window = UNSET
        else:
            selected_at_window = _selected_at_window  # type: ignore[arg-type]

        _selection_type = d.pop("selection_type", UNSET)
        selection_type: Union[Unset, SceneSelectionType]
        if isinstance(_selection_type, Unset):
            selection_type = UNSET
        else:
            selection_type = _selection_type  # type: ignore[arg-type]

        select_with_point = cls(
            selected_at_window=selected_at_window,
            selection_type=selection_type,
        )

        select_with_point.additional_properties = d
        return select_with_point

    @property

UQ = TypeVar("UQ", bound="select_clear")

class select_clear:
    """Clear the selection"""  # noqa: E501

    type: str = "select_clear"

    def from_dict(cls: Type[UQ], src_dict: Dict[str, Any]) -> UQ:

        select_clear = cls(
        )

        select_clear.additional_properties = d
        return select_clear

    @property

QE = TypeVar("QE", bound="select_add")

class select_add:
    """Adds one or more entities (by UUID) to the selection."""  # noqa: E501

    entities: Union[Unset, List[str]] = UNSET
    type: str = "select_add"

        entities: Union[Unset, List[str]] = UNSET
        if not isinstance(self.entities, Unset):
            entities = self.entities

        if entities is not UNSET:
            field_dict["entities"] = entities

    def from_dict(cls: Type[QE], src_dict: Dict[str, Any]) -> QE:
        entities = cast(List[str], d.pop("entities", UNSET))

        select_add = cls(
            entities=entities,
        )

        select_add.additional_properties = d
        return select_add

    @property

XH = TypeVar("XH", bound="select_remove")

class select_remove:
    """Removes one or more entities (by UUID) from the selection."""  # noqa: E501

    type: str = "select_remove"

    def from_dict(cls: Type[XH], src_dict: Dict[str, Any]) -> XH:

        select_remove = cls(
        )

        select_remove.additional_properties = d
        return select_remove

    @property

KT = TypeVar("KT", bound="select_replace")

class select_replace:
    """Replaces the current selection with these new entities (by UUID). Equivalent to doing SelectClear then SelectAdd."""  # noqa: E501

    type: str = "select_replace"

    def from_dict(cls: Type[KT], src_dict: Dict[str, Any]) -> KT:

        select_replace = cls(
        )

        select_replace.additional_properties = d
        return select_replace

    @property

BV = TypeVar("BV", bound="select_get")

class select_get:
    """Find all IDs of selected entities"""  # noqa: E501

    type: str = "select_get"

    def from_dict(cls: Type[BV], src_dict: Dict[str, Any]) -> BV:

        select_get = cls(
        )

        select_get.additional_properties = d
        return select_get

    @property

GU = TypeVar("GU", bound="highlight_set_entity")

class highlight_set_entity:
    """Changes the current highlighted entity to whichever one is at the given window coordinate. If there's no entity at this location, clears the highlight."""  # noqa: E501

    type: str = "highlight_set_entity"

    def from_dict(cls: Type[GU], src_dict: Dict[str, Any]) -> GU:
        else:

        highlight_set_entity = cls(
        )

        highlight_set_entity.additional_properties = d
        return highlight_set_entity

    @property

SS = TypeVar("SS", bound="highlight_set_entities")

class highlight_set_entities:
    """Changes the current highlighted entity to these entities."""  # noqa: E501

    type: str = "highlight_set_entities"

    def from_dict(cls: Type[SS], src_dict: Dict[str, Any]) -> SS:

        highlight_set_entities = cls(
        )

        highlight_set_entities.additional_properties = d
        return highlight_set_entities

    @property

UP = TypeVar("UP", bound="new_annotation")

class new_annotation:
    """Create a new annotation"""  # noqa: E501

    annotation_type: Union[Unset, AnnotationType] = UNSET
    clobber: Union[Unset, bool] = False
    options: Union[Unset, AnnotationOptions] = UNSET
    type: str = "new_annotation"

        if not isinstance(self.annotation_type, Unset):
            annotation_type = self.annotation_type
        clobber = self.clobber
        if not isinstance(self.options, Unset):
            options = self.options

        if annotation_type is not UNSET:
            field_dict["annotation_type"] = annotation_type
        if clobber is not UNSET:
            field_dict["clobber"] = clobber
        if options is not UNSET:
            field_dict["options"] = options

    def from_dict(cls: Type[UP], src_dict: Dict[str, Any]) -> UP:
        _annotation_type = d.pop("annotation_type", UNSET)
        annotation_type: Union[Unset, AnnotationType]
        if isinstance(_annotation_type, Unset):
            annotation_type = UNSET
        else:
            annotation_type = _annotation_type  # type: ignore[arg-type]

        clobber = d.pop("clobber", UNSET)

        _options = d.pop("options", UNSET)
        options: Union[Unset, AnnotationOptions]
        if isinstance(_options, Unset):
            options = UNSET
        else:
            options = _options  # type: ignore[arg-type]

        new_annotation = cls(
            annotation_type=annotation_type,
            clobber=clobber,
            options=options,
        )

        new_annotation.additional_properties = d
        return new_annotation

    @property

AZ = TypeVar("AZ", bound="update_annotation")

class update_annotation:
    """Update an annotation"""  # noqa: E501

    annotation_id: Union[Unset, str] = UNSET
    type: str = "update_annotation"

        annotation_id = self.annotation_id

        if annotation_id is not UNSET:
            field_dict["annotation_id"] = annotation_id

    def from_dict(cls: Type[AZ], src_dict: Dict[str, Any]) -> AZ:
        annotation_id = d.pop("annotation_id", UNSET)

        else:

        update_annotation = cls(
            annotation_id=annotation_id,
        )

        update_annotation.additional_properties = d
        return update_annotation

    @property

DJ = TypeVar("DJ", bound="object_visible")

class object_visible:
    """Hide or show an object"""  # noqa: E501

    hidden: Union[Unset, bool] = False
    object_id: Union[Unset, str] = UNSET
    type: str = "object_visible"

        hidden = self.hidden
        object_id = self.object_id

        if hidden is not UNSET:
            field_dict["hidden"] = hidden
        if object_id is not UNSET:
            field_dict["object_id"] = object_id

    def from_dict(cls: Type[DJ], src_dict: Dict[str, Any]) -> DJ:
        hidden = d.pop("hidden", UNSET)

        object_id = d.pop("object_id", UNSET)

        object_visible = cls(
            hidden=hidden,
            object_id=object_id,
        )

        object_visible.additional_properties = d
        return object_visible

    @property

WJ = TypeVar("WJ", bound="get_entity_type")

class get_entity_type:
    """What type of entity is this?"""  # noqa: E501

    type: str = "get_entity_type"

    def from_dict(cls: Type[WJ], src_dict: Dict[str, Any]) -> WJ:

        get_entity_type = cls(
        )

        get_entity_type.additional_properties = d
        return get_entity_type

    @property

TR = TypeVar("TR", bound="solid3d_get_all_edge_faces")

class solid3d_get_all_edge_faces:
    """Gets all faces which use the given edge."""  # noqa: E501

    edge_id: Union[Unset, str] = UNSET
    type: str = "solid3d_get_all_edge_faces"

        edge_id = self.edge_id

        if edge_id is not UNSET:
            field_dict["edge_id"] = edge_id

    def from_dict(cls: Type[TR], src_dict: Dict[str, Any]) -> TR:
        edge_id = d.pop("edge_id", UNSET)

        solid3d_get_all_edge_faces = cls(
            edge_id=edge_id,
        )

        solid3d_get_all_edge_faces.additional_properties = d
        return solid3d_get_all_edge_faces

    @property

YD = TypeVar("YD", bound="solid3d_get_all_opposite_edges")

class solid3d_get_all_opposite_edges:
    """Gets all edges which are opposite the given edge, across all possible faces."""  # noqa: E501

    along_vector: Union[Unset, Point3d] = UNSET
    type: str = "solid3d_get_all_opposite_edges"

        if not isinstance(self.along_vector, Unset):
            along_vector = self.along_vector

        if along_vector is not UNSET:
            field_dict["along_vector"] = along_vector

    def from_dict(cls: Type[YD], src_dict: Dict[str, Any]) -> YD:
        _along_vector = d.pop("along_vector", UNSET)
        along_vector: Union[Unset, Point3d]
        if isinstance(_along_vector, Unset):
            along_vector = UNSET
        else:
            along_vector = _along_vector  # type: ignore[arg-type]

        solid3d_get_all_opposite_edges = cls(
            along_vector=along_vector,
        )

        solid3d_get_all_opposite_edges.additional_properties = d
        return solid3d_get_all_opposite_edges

    @property

JF = TypeVar("JF", bound="solid3d_get_opposite_edge")

class solid3d_get_opposite_edge:
    """Gets the edge opposite the given edge, along the given face."""  # noqa: E501

    face_uuid: Union[Unset, str] = UNSET
    type: str = "solid3d_get_opposite_edge"

        face_uuid = self.face_uuid

        if face_uuid is not UNSET:
            field_dict["face_uuid"] = face_uuid

    def from_dict(cls: Type[JF], src_dict: Dict[str, Any]) -> JF:

        face_uuid = d.pop("face_uuid", UNSET)

        solid3d_get_opposite_edge = cls(
            face_uuid=face_uuid,
        )

        solid3d_get_opposite_edge.additional_properties = d
        return solid3d_get_opposite_edge

    @property

VP = TypeVar("VP", bound="solid3d_get_next_adjacent_edge")

class solid3d_get_next_adjacent_edge:
    """Gets the next adjacent edge for the given edge, along the given face."""  # noqa: E501

    type: str = "solid3d_get_next_adjacent_edge"

    def from_dict(cls: Type[VP], src_dict: Dict[str, Any]) -> VP:

        solid3d_get_next_adjacent_edge = cls(
        )

        solid3d_get_next_adjacent_edge.additional_properties = d
        return solid3d_get_next_adjacent_edge

    @property

EL = TypeVar("EL", bound="solid3d_get_prev_adjacent_edge")

class solid3d_get_prev_adjacent_edge:
    """Gets the previous adjacent edge for the given edge, along the given face."""  # noqa: E501

    type: str = "solid3d_get_prev_adjacent_edge"

    def from_dict(cls: Type[EL], src_dict: Dict[str, Any]) -> EL:

        solid3d_get_prev_adjacent_edge = cls(
        )

        solid3d_get_prev_adjacent_edge.additional_properties = d
        return solid3d_get_prev_adjacent_edge

    @property

ModelingCmd = Union[
    start_path,
    move_path_pen,
    extend_path,
    extrude,
    close_path,
    camera_drag_start,
    camera_drag_move,
    camera_drag_end,
    default_camera_look_at,
    default_camera_enable_sketch_mode,
    default_camera_disable_sketch_mode,
    export,
    entity_get_parent_id,
    entity_get_num_children,
    entity_get_child_uuid,
    entity_get_all_child_uuids,
    edit_mode_enter,
    edit_mode_exit,
    select_with_point,
    select_clear,
    select_add,
    select_remove,
    select_replace,
    select_get,
    highlight_set_entity,
    highlight_set_entities,
    new_annotation,
    update_annotation,
    object_visible,
    get_entity_type,
    solid3d_get_all_edge_faces,
    solid3d_get_all_opposite_edges,
    solid3d_get_opposite_edge,
    solid3d_get_next_adjacent_edge,
    solid3d_get_prev_adjacent_edge,
]

class ModelingCmdId(str):
        return self

from ..models.modeling_cmd import ModelingCmd

ZG = TypeVar("ZG", bound="ModelingCmdReq")

class ModelingCmdReq:
    """A graphics command submitted to the KittyCAD engine via the Modeling API."""  # noqa: E501

    cmd: Union[Unset, ModelingCmd] = UNSET
    cmd_id: Union[Unset, ModelingCmdId] = UNSET

        if not isinstance(self.cmd, Unset):
            cmd = self.cmd
        if not isinstance(self.cmd_id, Unset):
            cmd_id = self.cmd_id

        if cmd is not UNSET:
            field_dict["cmd"] = cmd
        if cmd_id is not UNSET:
            field_dict["cmd_id"] = cmd_id

    def from_dict(cls: Type[ZG], src_dict: Dict[str, Any]) -> ZG:
        _cmd = d.pop("cmd", UNSET)
        cmd: Union[Unset, ModelingCmd]
        if isinstance(_cmd, Unset):
            cmd = UNSET
        else:
            cmd = _cmd  # type: ignore[arg-type]

        _cmd_id = d.pop("cmd_id", UNSET)
        cmd_id: Union[Unset, ModelingCmdId]
        if isinstance(_cmd_id, Unset):
            cmd_id = UNSET
        else:
            cmd_id = _cmd_id  # type: ignore[arg-type]

        modeling_cmd_req = cls(
            cmd=cmd,
            cmd_id=cmd_id,
        )

        modeling_cmd_req.additional_properties = d
        return modeling_cmd_req

    @property

LF = TypeVar("LF", bound="ModelingCmdReqBatch")

class ModelingCmdReqBatch:
    """A batch set of graphics commands submitted to the KittyCAD engine via the Modeling API."""  # noqa: E501

    cmds: Union[Unset, Any] = UNSET

        cmds = self.cmds

        if cmds is not UNSET:
            field_dict["cmds"] = cmds

    def from_dict(cls: Type[LF], src_dict: Dict[str, Any]) -> LF:
        cmds = d.pop("cmds", UNSET)

        modeling_cmd_req_batch = cls(
            cmds=cmds,
        )

        modeling_cmd_req_batch.additional_properties = d
        return modeling_cmd_req_batch

    @property

CS = TypeVar("CS", bound="ModelingError")

class ModelingError:
    """Why a command submitted to the Modeling API failed."""  # noqa: E501

    external_message: Union[Unset, str] = UNSET
    internal_message: Union[Unset, str] = UNSET

        external_message = self.external_message
        internal_message = self.internal_message

        if external_message is not UNSET:
            field_dict["external_message"] = external_message
        if internal_message is not UNSET:
            field_dict["internal_message"] = internal_message

    def from_dict(cls: Type[CS], src_dict: Dict[str, Any]) -> CS:

        external_message = d.pop("external_message", UNSET)

        internal_message = d.pop("internal_message", UNSET)

        modeling_error = cls(
            external_message=external_message,
            internal_message=internal_message,
        )

        modeling_error.additional_properties = d
        return modeling_error

    @property

from .modeling_error import ModelingError
from .ok_modeling_cmd_response import OkModelingCmdResponse

success = OkModelingCmdResponse

error = ModelingError

GN = TypeVar("GN", bound="cancelled")

class cancelled:
    what_failed: Union[Unset, ModelingCmdId] = UNSET

        if not isinstance(self.what_failed, Unset):
            what_failed = self.what_failed

        if what_failed is not UNSET:
            field_dict["what_failed"] = what_failed

    def from_dict(cls: Type[GN], src_dict: Dict[str, Any]) -> GN:
        _what_failed = d.pop("what_failed", UNSET)
        what_failed: Union[Unset, ModelingCmdId]
        if isinstance(_what_failed, Unset):
            what_failed = UNSET
        else:
            what_failed = _what_failed  # type: ignore[arg-type]

        cancelled = cls(
            what_failed=what_failed,
        )

        cancelled.additional_properties = d
        return cancelled

    @property

ModelingOutcome = Union[success, error, cancelled]

GD = TypeVar("GD", bound="ModelingOutcomes")

class ModelingOutcomes:
    """The result from a batch of modeling commands."""  # noqa: E501

    outcomes: Union[Unset, Any] = UNSET

        outcomes = self.outcomes

        if outcomes is not UNSET:
            field_dict["outcomes"] = outcomes

    def from_dict(cls: Type[GD], src_dict: Dict[str, Any]) -> GD:
        outcomes = d.pop("outcomes", UNSET)

        modeling_outcomes = cls(
            outcomes=outcomes,
        )

        modeling_outcomes.additional_properties = d
        return modeling_outcomes

    @property

from ..models.country_code import CountryCode

VJ = TypeVar("VJ", bound="NewAddress")

class NewAddress:
    """The struct that is used to create a new record. This is automatically generated and has all the same fields as the main struct only it is missing the `id`."""  # noqa: E501

    city: Union[Unset, str] = UNSET
    country: Union[Unset, CountryCode] = UNSET
    state: Union[Unset, str] = UNSET
    street1: Union[Unset, str] = UNSET
    street2: Union[Unset, str] = UNSET
    zip: Union[Unset, str] = UNSET

        city = self.city
        if not isinstance(self.country, Unset):
            country = self.country
        state = self.state
        street1 = self.street1
        street2 = self.street2
        zip = self.zip

        if city is not UNSET:
            field_dict["city"] = city
        if state is not UNSET:
            field_dict["state"] = state
        if street1 is not UNSET:
            field_dict["street1"] = street1
        if street2 is not UNSET:
            field_dict["street2"] = street2
        if zip is not UNSET:
            field_dict["zip"] = zip

    def from_dict(cls: Type[VJ], src_dict: Dict[str, Any]) -> VJ:
        city = d.pop("city", UNSET)

        _country = d.pop("country", UNSET)
        country: Union[Unset, CountryCode]
        if isinstance(_country, Unset):
            country = UNSET
        else:
            country = _country  # type: ignore[arg-type]

        state = d.pop("state", UNSET)

        street1 = d.pop("street1", UNSET)

        street2 = d.pop("street2", UNSET)

        zip = d.pop("zip", UNSET)

        new_address = cls(
            city=city,
            state=state,
            street1=street1,
            street2=street2,
            zip=zip,
        )

        new_address.additional_properties = d
        return new_address

    @property

OX = TypeVar("OX", bound="OAuth2ClientInfo")

class OAuth2ClientInfo:
    """Information about an OAuth 2.0 client."""  # noqa: E501

    csrf_token: Union[Unset, str] = UNSET
    pkce_code_verifier: Union[Unset, str] = UNSET

        csrf_token = self.csrf_token
        pkce_code_verifier = self.pkce_code_verifier

        if csrf_token is not UNSET:
            field_dict["csrf_token"] = csrf_token
        if pkce_code_verifier is not UNSET:
            field_dict["pkce_code_verifier"] = pkce_code_verifier

    def from_dict(cls: Type[OX], src_dict: Dict[str, Any]) -> OX:
        csrf_token = d.pop("csrf_token", UNSET)

        pkce_code_verifier = d.pop("pkce_code_verifier", UNSET)

        o_auth2_client_info = cls(
            csrf_token=csrf_token,
            pkce_code_verifier=pkce_code_verifier,
            url=url,
        )

        o_auth2_client_info.additional_properties = d
        return o_auth2_client_info

    @property

class OAuth2GrantType(str, Enum):
    """An OAuth 2.0 Grant Type. These are documented here: <https://oauth.net/2/grant-types/>."""  # noqa: E501

    """# An OAuth 2.0 Device Authorization Grant. """  # noqa: E501
    URN_IETF_PARAMS_OAUTH_GRANT_TYPE_DEVICE_CODE = (
        "urn:ietf:params:oauth:grant-type:device_code"
    )

from ..models.entity_type import EntityType

YW = TypeVar("YW", bound="empty")

class empty:
    """An empty response, used for any command that does not explicitly have a response defined here."""  # noqa: E501

    type: str = "empty"

    def from_dict(cls: Type[YW], src_dict: Dict[str, Any]) -> YW:

        empty = cls(
        )

        empty.additional_properties = d
        return empty

    @property

QX = TypeVar("QX", bound="export")

    """The response from the `Export` command. When this is being performed over a websocket, this is sent as binary not JSON. The binary data can be deserialized as `bincode` into a `Vec<ExportFile>`."""  # noqa: E501

    from ..models.export_file import ExportFile

    files: Union[Unset, List[ExportFile]] = UNSET

        from ..models.export_file import ExportFile

        files: Union[Unset, List[ExportFile]] = UNSET
        if not isinstance(self.files, Unset):
            files = self.files

        if files is not UNSET:
            field_dict["files"] = files

    def from_dict(cls: Type[QX], src_dict: Dict[str, Any]) -> QX:

        files = cast(List[ExportFile], d.pop("files", UNSET))

            files=files,
        )

    @property

NO = TypeVar("NO", bound="select_with_point")

    """The response from the `SelectWithPoint` command."""  # noqa: E501

    def from_dict(cls: Type[NO], src_dict: Dict[str, Any]) -> NO:

        )

    @property

VX = TypeVar("VX", bound="highlight_set_entity")

    """The response from the `HighlightSetEntity` command."""  # noqa: E501

    def from_dict(cls: Type[VX], src_dict: Dict[str, Any]) -> VX:

        )

    @property

RG = TypeVar("RG", bound="entity_get_child_uuid")

    """The response from the `EntityGetChildUuid` command."""  # noqa: E501

    def from_dict(cls: Type[RG], src_dict: Dict[str, Any]) -> RG:

        )

    @property

IT = TypeVar("IT", bound="entity_get_num_children")

    """The response from the `EntityGetNumChildren` command."""  # noqa: E501

    num: Union[Unset, int] = UNSET

        num = self.num

        if num is not UNSET:
            field_dict["num"] = num

    def from_dict(cls: Type[IT], src_dict: Dict[str, Any]) -> IT:
        num = d.pop("num", UNSET)

            num=num,
        )

    @property

LD = TypeVar("LD", bound="entity_get_parent_id")

    """The response from the `EntityGetParentId` command."""  # noqa: E501

    def from_dict(cls: Type[LD], src_dict: Dict[str, Any]) -> LD:

        )

    @property

UA = TypeVar("UA", bound="entity_get_all_child_uuids")

    """The response from the `EntityGetAllChildUuids` command."""  # noqa: E501

    def from_dict(cls: Type[UA], src_dict: Dict[str, Any]) -> UA:

        )

    @property

TN = TypeVar("TN", bound="select_get")

    """The response from the `SelectGet` command."""  # noqa: E501

    def from_dict(cls: Type[TN], src_dict: Dict[str, Any]) -> TN:

        )

    @property

MZ = TypeVar("MZ", bound="get_entity_type")

    """The response from the `GetEntityType` command."""  # noqa: E501

    entity_type: Union[Unset, EntityType] = UNSET

        if not isinstance(self.entity_type, Unset):
            entity_type = self.entity_type

        if entity_type is not UNSET:
            field_dict["entity_type"] = entity_type

    def from_dict(cls: Type[MZ], src_dict: Dict[str, Any]) -> MZ:
        _entity_type = d.pop("entity_type", UNSET)
        entity_type: Union[Unset, EntityType]
        if isinstance(_entity_type, Unset):
            entity_type = UNSET
        else:
            entity_type = _entity_type  # type: ignore[arg-type]

            entity_type=entity_type,
        )

    @property

UG = TypeVar("UG", bound="solid3d_get_all_edge_faces")

    """The response from the `Solid3dGetAllEdgeFaces` command."""  # noqa: E501

    faces: Union[Unset, List[str]] = UNSET

        faces: Union[Unset, List[str]] = UNSET
        if not isinstance(self.faces, Unset):
            faces = self.faces

        if faces is not UNSET:
            field_dict["faces"] = faces

    def from_dict(cls: Type[UG], src_dict: Dict[str, Any]) -> UG:
        faces = cast(List[str], d.pop("faces", UNSET))

            faces=faces,
        )

    @property

CY = TypeVar("CY", bound="solid3d_get_all_opposite_edges")

    """The response from the `Solid3dGetAllOppositeEdges` command."""  # noqa: E501

    edges: Union[Unset, List[str]] = UNSET

        edges: Union[Unset, List[str]] = UNSET
        if not isinstance(self.edges, Unset):
            edges = self.edges

        if edges is not UNSET:
            field_dict["edges"] = edges

    def from_dict(cls: Type[CY], src_dict: Dict[str, Any]) -> CY:
        edges = cast(List[str], d.pop("edges", UNSET))

            edges=edges,
        )

    @property

NZ = TypeVar("NZ", bound="solid3d_get_opposite_edge")

    """The response from the `Solid3dGetOppositeEdge` command."""  # noqa: E501

    edge: Union[Unset, str] = UNSET

        edge = self.edge

        if edge is not UNSET:
            field_dict["edge"] = edge

    def from_dict(cls: Type[NZ], src_dict: Dict[str, Any]) -> NZ:
        edge = d.pop("edge", UNSET)

            edge=edge,
        )

    @property

LI = TypeVar("LI", bound="solid3d_get_prev_adjacent_edge")

    """The response from the `Solid3dGetPrevAdjacentEdge` command."""  # noqa: E501

    def from_dict(cls: Type[LI], src_dict: Dict[str, Any]) -> LI:

        )

    @property

LO = TypeVar("LO", bound="solid3d_get_next_adjacent_edge")

    """The response from the `Solid3dGetNextAdjacentEdge` command."""  # noqa: E501

    def from_dict(cls: Type[LO], src_dict: Dict[str, Any]) -> LO:

        )

    @property

OkModelingCmdResponse = Union[
    empty,
    export,
]

XJ = TypeVar("XJ", bound="Onboarding")

class Onboarding:
    """Onboarding details"""  # noqa: E501

    first_call_from__their_machine_date: Union[Unset, str] = UNSET
    first_litterbox_execute_date: Union[Unset, str] = UNSET
    first_token_date: Union[Unset, str] = UNSET

        first_call_from__their_machine_date = self.first_call_from__their_machine_date
        first_litterbox_execute_date = self.first_litterbox_execute_date
        first_token_date = self.first_token_date

        if first_call_from__their_machine_date is not UNSET:
            field_dict[
                "first_call_from_their_machine_date"
            ] = first_call_from__their_machine_date
        if first_litterbox_execute_date is not UNSET:
            field_dict["first_litterbox_execute_date"] = first_litterbox_execute_date
        if first_token_date is not UNSET:
            field_dict["first_token_date"] = first_token_date

    def from_dict(cls: Type[XJ], src_dict: Dict[str, Any]) -> XJ:
        first_call_from__their_machine_date = d.pop(
            "first_call_from_their_machine_date", UNSET
        )

        first_litterbox_execute_date = d.pop("first_litterbox_execute_date", UNSET)

        first_token_date = d.pop("first_token_date", UNSET)

        onboarding = cls(
            first_call_from__their_machine_date=first_call_from__their_machine_date,
            first_litterbox_execute_date=first_litterbox_execute_date,
            first_token_date=first_token_date,
        )

        onboarding.additional_properties = d
        return onboarding

    @property

OW = TypeVar("OW", bound="OutputFile")

class OutputFile:
    """Output file contents."""  # noqa: E501

    def from_dict(cls: Type[OW], src_dict: Dict[str, Any]) -> OW:

        output_file = cls(
        )

        output_file.additional_properties = d
        return output_file

    @property

from ..models.storage import Storage

JQ = TypeVar("JQ", bound="gltf")

    """glTF 2.0. We refer to this as glTF since that is how our customers refer to it, although by default it will be in binary format and thus technically (glb). If you prefer ascii output, you can set that option for the export."""  # noqa: E501

    storage: Union[Unset, Storage] = UNSET

        if not isinstance(self.storage, Unset):
            storage = self.storage

        if storage is not UNSET:
            field_dict["storage"] = storage

    def from_dict(cls: Type[JQ], src_dict: Dict[str, Any]) -> JQ:
        _storage = d.pop("storage", UNSET)
        storage: Union[Unset, Storage]
        if isinstance(_storage, Unset):
            storage = UNSET
        else:
            storage = _storage  # type: ignore[arg-type]

        gltf = cls(
            storage=storage,
        )

    @property

PQ = TypeVar("PQ", bound="obj")

class obj:

    def from_dict(cls: Type[PQ], src_dict: Dict[str, Any]) -> PQ:
        else:

        obj = cls(
        )

        return obj

    @property

IM = TypeVar("IM", bound="ply")

class ply:

    def from_dict(cls: Type[IM], src_dict: Dict[str, Any]) -> IM:
        else:

        else:

        ply = cls(
        )

        return ply

    @property

OU = TypeVar("OU", bound="step")

    def from_dict(cls: Type[OU], src_dict: Dict[str, Any]) -> OU:
        else:

        step = cls(
        )

    @property

KL = TypeVar("KL", bound="stl")

class stl:

    def from_dict(cls: Type[KL], src_dict: Dict[str, Any]) -> KL:
        else:

        else:

        stl = cls(
        )

        return stl

    @property

OutputFormat = Union[gltf, obj, ply, step, stl]

XI = TypeVar("XI", bound="line")

class line:
    """A straight line segment. Goes from the current path "pen" to the given endpoint."""  # noqa: E501

    end: Union[Unset, Point3d] = UNSET
    type: str = "line"

    def from_dict(cls: Type[XI], src_dict: Dict[str, Any]) -> XI:
        end: Union[Unset, Point3d]
            end = UNSET
        else:

        line = cls(
            end=end,
        )

        line.additional_properties = d
        return line

    @property

PO = TypeVar("PO", bound="arc")

class arc:
    """A circular arc segment."""  # noqa: E501

    angle_end: Union[Unset, float] = UNSET
    angle_start: Union[Unset, float] = UNSET
    center: Union[Unset, Point2d] = UNSET
    radius: Union[Unset, float] = UNSET
    type: str = "arc"

        angle_end = self.angle_end
        angle_start = self.angle_start
        radius = self.radius

        if angle_end is not UNSET:
            field_dict["angle_end"] = angle_end
        if angle_start is not UNSET:
            field_dict["angle_start"] = angle_start
        if radius is not UNSET:
            field_dict["radius"] = radius

    def from_dict(cls: Type[PO], src_dict: Dict[str, Any]) -> PO:
        angle_end = d.pop("angle_end", UNSET)

        angle_start = d.pop("angle_start", UNSET)

        center: Union[Unset, Point2d]
        else:

        radius = d.pop("radius", UNSET)

        arc = cls(
            angle_end=angle_end,
            angle_start=angle_start,
            radius=radius,
        )

        arc.additional_properties = d
        return arc

    @property

PS = TypeVar("PS", bound="bezier")

class bezier:
    """A cubic bezier curve segment. Start at the end of the current line, go through control point 1 and 2, then end at a given point."""  # noqa: E501

    control1: Union[Unset, Point3d] = UNSET
    control2: Union[Unset, Point3d] = UNSET
    type: str = "bezier"

        if not isinstance(self.control1, Unset):
            control1 = self.control1
        if not isinstance(self.control2, Unset):
            control2 = self.control2

        if control1 is not UNSET:
            field_dict["control1"] = control1
        if control2 is not UNSET:
            field_dict["control2"] = control2

    def from_dict(cls: Type[PS], src_dict: Dict[str, Any]) -> PS:
        _control1 = d.pop("control1", UNSET)
        control1: Union[Unset, Point3d]
        if isinstance(_control1, Unset):
            control1 = UNSET
        else:
            control1 = _control1  # type: ignore[arg-type]

        _control2 = d.pop("control2", UNSET)
        control2: Union[Unset, Point3d]
        if isinstance(_control2, Unset):
            control2 = UNSET
        else:
            control2 = _control2  # type: ignore[arg-type]

            end = UNSET
        else:

        bezier = cls(
            control1=control1,
            control2=control2,
            end=end,
        )

        bezier.additional_properties = d
        return bezier

    @property

PathSegment = Union[line, arc, bezier]

WR = TypeVar("WR", bound="PaymentIntent")

class PaymentIntent:
    """A payment intent response."""  # noqa: E501

    client_secret: Union[Unset, str] = UNSET

        client_secret = self.client_secret

        if client_secret is not UNSET:
            field_dict["client_secret"] = client_secret

    def from_dict(cls: Type[WR], src_dict: Dict[str, Any]) -> WR:
        client_secret = d.pop("client_secret", UNSET)

        payment_intent = cls(
            client_secret=client_secret,
        )

        payment_intent.additional_properties = d
        return payment_intent

    @property

from ..models.billing_info import BillingInfo
from ..models.card_details import CardDetails
from ..models.payment_method_type import PaymentMethodType

XL = TypeVar("XL", bound="PaymentMethod")

class PaymentMethod:
    """A payment method."""  # noqa: E501

    billing_info: Union[Unset, BillingInfo] = UNSET
    card: Union[Unset, CardDetails] = UNSET
    type: Union[Unset, PaymentMethodType] = UNSET

        if not isinstance(self.billing_info, Unset):
            billing_info = self.billing_info
        if not isinstance(self.card, Unset):
            card = self.card

        if billing_info is not UNSET:
            field_dict["billing_info"] = billing_info
        if card is not UNSET:
            field_dict["card"] = card

    def from_dict(cls: Type[XL], src_dict: Dict[str, Any]) -> XL:
        _billing_info = d.pop("billing_info", UNSET)
        billing_info: Union[Unset, BillingInfo]
        if isinstance(_billing_info, Unset):
            billing_info = UNSET
        else:
            billing_info = _billing_info  # type: ignore[arg-type]

        _card = d.pop("card", UNSET)
        card: Union[Unset, CardDetails]
        if isinstance(_card, Unset):
            card = UNSET
        else:
            card = _card  # type: ignore[arg-type]

        else:

        type: Union[Unset, PaymentMethodType]
        else:

        payment_method = cls(
            billing_info=billing_info,
            card=card,
            id=id,
        )

        payment_method.additional_properties = d
        return payment_method

    @property

ZX = TypeVar("ZX", bound="PaymentMethodCardChecks")

class PaymentMethodCardChecks:
    """Card checks."""  # noqa: E501

    address_line1_check: Union[Unset, str] = UNSET
    address_postal_code_check: Union[Unset, str] = UNSET
    cvc_check: Union[Unset, str] = UNSET

        address_line1_check = self.address_line1_check
        address_postal_code_check = self.address_postal_code_check
        cvc_check = self.cvc_check

        if address_line1_check is not UNSET:
            field_dict["address_line1_check"] = address_line1_check
        if address_postal_code_check is not UNSET:
            field_dict["address_postal_code_check"] = address_postal_code_check
        if cvc_check is not UNSET:
            field_dict["cvc_check"] = cvc_check

    def from_dict(cls: Type[ZX], src_dict: Dict[str, Any]) -> ZX:
        address_line1_check = d.pop("address_line1_check", UNSET)

        address_postal_code_check = d.pop("address_postal_code_check", UNSET)

        cvc_check = d.pop("cvc_check", UNSET)

        payment_method_card_checks = cls(
            address_line1_check=address_line1_check,
            address_postal_code_check=address_postal_code_check,
            cvc_check=cvc_check,
        )

        payment_method_card_checks.additional_properties = d
        return payment_method_card_checks

    @property

class PaymentMethodType(str, Enum):
    """An enum representing the possible values of an `PaymentMethod`'s `type` field."""  # noqa: E501

    """# A card payment method. """  # noqa: E501
    CARD = "card"

FT = TypeVar("FT", bound="PluginsInfo")

class PluginsInfo:
    """Available plugins per type.

    **Note**: Only unmanaged (V1) plugins are included in this list. V1 plugins are \"lazily\" loaded, and are not returned in this list if there is no resource using the plugin.

    authorization: Union[Unset, List[str]] = UNSET
    log: Union[Unset, List[str]] = UNSET
    network: Union[Unset, List[str]] = UNSET
    volume: Union[Unset, List[str]] = UNSET

        authorization: Union[Unset, List[str]] = UNSET
        if not isinstance(self.authorization, Unset):
            authorization = self.authorization
        log: Union[Unset, List[str]] = UNSET
        if not isinstance(self.log, Unset):
            log = self.log
        network: Union[Unset, List[str]] = UNSET
        if not isinstance(self.network, Unset):
            network = self.network
        volume: Union[Unset, List[str]] = UNSET
        if not isinstance(self.volume, Unset):
            volume = self.volume

        if authorization is not UNSET:
            field_dict["authorization"] = authorization
        if log is not UNSET:
            field_dict["log"] = log
        if network is not UNSET:
            field_dict["network"] = network

    def from_dict(cls: Type[FT], src_dict: Dict[str, Any]) -> FT:
        authorization = cast(List[str], d.pop("authorization", UNSET))

        log = cast(List[str], d.pop("log", UNSET))

        network = cast(List[str], d.pop("network", UNSET))

        volume = cast(List[str], d.pop("volume", UNSET))

        plugins_info = cls(
            authorization=authorization,
            log=log,
            network=network,
        )

        plugins_info.additional_properties = d
        return plugins_info

    @property

NX = TypeVar("NX", bound="Point2d")

class Point2d:
    """A point in 2D space"""  # noqa: E501

    x: Union[Unset, float] = UNSET
    y: Union[Unset, float] = UNSET

        x = self.x
        y = self.y

    def from_dict(cls: Type[NX], src_dict: Dict[str, Any]) -> NX:
        x = d.pop("x", UNSET)

        y = d.pop("y", UNSET)

        point2d = cls(
            x=x,
            y=y,
        )

        point2d.additional_properties = d
        return point2d

    @property

SC = TypeVar("SC", bound="Point3d")

class Point3d:
    """A point in 3D space"""  # noqa: E501

    z: Union[Unset, float] = UNSET

        x = self.x
        y = self.y
        z = self.z

        if z is not UNSET:
            field_dict["z"] = z

    def from_dict(cls: Type[SC], src_dict: Dict[str, Any]) -> SC:

        z = d.pop("z", UNSET)

        point3d = cls(
            x=x,
            y=y,
            z=z,
        )

        point3d.additional_properties = d
        return point3d

    @property

TX = TypeVar("TX", bound="PointEMetadata")

class PointEMetadata:
    """Metadata about our point-e instance.

    def from_dict(cls: Type[TX], src_dict: Dict[str, Any]) -> TX:

        point_e_metadata = cls(
            ok=ok,
        )

        point_e_metadata.additional_properties = d
        return point_e_metadata

    @property

JA = TypeVar("JA", bound="Pong")

class Pong:
    """The response from the `/ping` endpoint."""  # noqa: E501

    def from_dict(cls: Type[JA], src_dict: Dict[str, Any]) -> JA:

        pong = cls(
        )

        pong.additional_properties = d
        return pong

    @property

SK = TypeVar("SK", bound="RegistryServiceConfig")

class RegistryServiceConfig:
    """RegistryServiceConfig stores daemon registry services configuration."""  # noqa: E501

    allow_nondistributable_artifacts_cid_rs: Union[Unset, List[str]] = UNSET
    allow_nondistributable_artifacts_hostnames: Union[Unset, List[str]] = UNSET
    index_configs: Union[Unset, Any] = UNSET
    insecure_registry_cid_rs: Union[Unset, List[str]] = UNSET

        allow_nondistributable_artifacts_cid_rs: Union[Unset, List[str]] = UNSET
        if not isinstance(self.allow_nondistributable_artifacts_cid_rs, Unset):
            allow_nondistributable_artifacts_cid_rs = (
                self.allow_nondistributable_artifacts_cid_rs
            )
        allow_nondistributable_artifacts_hostnames: Union[Unset, List[str]] = UNSET
        if not isinstance(self.allow_nondistributable_artifacts_hostnames, Unset):
            allow_nondistributable_artifacts_hostnames = (
                self.allow_nondistributable_artifacts_hostnames
            )
        index_configs = self.index_configs
        insecure_registry_cid_rs: Union[Unset, List[str]] = UNSET
        if not isinstance(self.insecure_registry_cid_rs, Unset):
            insecure_registry_cid_rs = self.insecure_registry_cid_rs

        if allow_nondistributable_artifacts_cid_rs is not UNSET:
                "allow_nondistributable_artifacts_cid_rs"
            ] = allow_nondistributable_artifacts_cid_rs
        if allow_nondistributable_artifacts_hostnames is not UNSET:
                "allow_nondistributable_artifacts_hostnames"
            ] = allow_nondistributable_artifacts_hostnames
        if index_configs is not UNSET:
            field_dict["index_configs"] = index_configs
        if insecure_registry_cid_rs is not UNSET:
            field_dict["insecure_registry_cid_rs"] = insecure_registry_cid_rs

    def from_dict(cls: Type[SK], src_dict: Dict[str, Any]) -> SK:
        allow_nondistributable_artifacts_cid_rs = cast(
            List[str], d.pop("allow_nondistributable_artifacts_cid_rs", UNSET)
        )

        allow_nondistributable_artifacts_hostnames = cast(
            List[str], d.pop("allow_nondistributable_artifacts_hostnames", UNSET)
        )

        index_configs = d.pop("index_configs", UNSET)
        insecure_registry_cid_rs = cast(
            List[str], d.pop("insecure_registry_cid_rs", UNSET)
        )

        registry_service_config = cls(
            allow_nondistributable_artifacts_cid_rs=allow_nondistributable_artifacts_cid_rs,
            allow_nondistributable_artifacts_hostnames=allow_nondistributable_artifacts_hostnames,
            index_configs=index_configs,
            insecure_registry_cid_rs=insecure_registry_cid_rs,
        )

        registry_service_config.additional_properties = d
        return registry_service_config

    @property

UK = TypeVar("UK", bound="Runtime")

class Runtime:
    """Runtime describes an [OCI compliant](https://github.com/opencontainers/runtime-spec) runtime.  The runtime is invoked by the daemon via the `containerd` daemon. OCI runtimes act as an interface to the Linux kernel namespaces, cgroups, and SELinux."""  # noqa: E501

    path: Union[Unset, str] = UNSET
    runtime_args: Union[Unset, List[str]] = UNSET

        path = self.path
        runtime_args: Union[Unset, List[str]] = UNSET
        if not isinstance(self.runtime_args, Unset):
            runtime_args = self.runtime_args

        if runtime_args is not UNSET:
            field_dict["runtime_args"] = runtime_args

    def from_dict(cls: Type[UK], src_dict: Dict[str, Any]) -> UK:
        path = d.pop("path", UNSET)

        runtime_args = cast(List[str], d.pop("runtime_args", UNSET))

        runtime = cls(
            runtime_args=runtime_args,
        )

        runtime.additional_properties = d
        return runtime

    @property

class SceneSelectionType(str, Enum):
    """The type of scene selection change"""  # noqa: E501

    """# Replaces the selection """  # noqa: E501
    REPLACE = "replace"
    """# Adds to the selection """  # noqa: E501
    ADD = "add"
    """# Removes from the selection """  # noqa: E501
    REMOVE = "remove"

CX = TypeVar("CX", bound="Session")

class Session:
    """An authentication session.

    For our UIs, these are automatically created by Next.js."""  # noqa: E501

    expires: Union[Unset, datetime.datetime] = UNSET
    session_token: Union[Unset, str] = UNSET

        expires: Union[Unset, str] = UNSET
        if not isinstance(self.expires, Unset):
            expires = self.expires.isoformat()
        session_token = self.session_token

        if expires is not UNSET:
            field_dict["expires"] = expires
        if session_token is not UNSET:
            field_dict["session_token"] = session_token

    def from_dict(cls: Type[CX], src_dict: Dict[str, Any]) -> CX:
        else:

        _expires = d.pop("expires", UNSET)
        expires: Union[Unset, datetime.datetime]
        if isinstance(_expires, Unset):
            expires = UNSET
        else:
            expires = isoparse(_expires)

        _session_token = d.pop("session_token", UNSET)
        session_token: Union[Unset, Uuid]
        if isinstance(_session_token, Unset):
            session_token = UNSET
        else:
            session_token = _session_token  # type: ignore[arg-type]

        else:

        session = cls(
            expires=expires,
            id=id,
            session_token=session_token,
        )

        session.additional_properties = d
        return session

    @property

class Storage(str, Enum):
    """Describes the storage format of a glTF 2.0 scene."""  # noqa: E501

    """# Binary glTF 2.0.

This is a single binary with .glb extension.

This is the default setting. """  # noqa: E501
    BINARY = "binary"
    """# Standard glTF 2.0.

This is a JSON file with .gltf extension paired with a separate binary blob file with .bin extension. """  # noqa: E501
    STANDARD = "standard"
    """# Embedded glTF 2.0.

Single JSON file with .gltf extension binary data encoded as base64 data URIs. """  # noqa: E501
    EMBEDDED = "embedded"

from ..models.axis_direction_pair import AxisDirectionPair

MT = TypeVar("MT", bound="System")

class System:
    """Co-ordinate system definition.

    The `up` axis must be orthogonal to the `forward` axis.

    [cglearn.eu](https://cglearn.eu/pub/computer-graphics/introduction-to-geometry#material-coordinate-systems-1)

    forward: Union[Unset, AxisDirectionPair] = UNSET
    up: Union[Unset, AxisDirectionPair] = UNSET

        if not isinstance(self.forward, Unset):
            forward = self.forward

        if forward is not UNSET:
            field_dict["forward"] = forward

    def from_dict(cls: Type[MT], src_dict: Dict[str, Any]) -> MT:
        _forward = d.pop("forward", UNSET)
        forward: Union[Unset, AxisDirectionPair]
        if isinstance(_forward, Unset):
            forward = UNSET
        else:
            forward = _forward  # type: ignore[arg-type]

        up: Union[Unset, AxisDirectionPair]
            up = UNSET
        else:

        system = cls(
            forward=forward,
            up=up,
        )

        system.additional_properties = d
        return system

    @property

class SystemInfoCgroupDriverEnum(str, Enum):
    EMPTY = ""
    CGROUPFS = "cgroupfs"
    SYSTEMD = "systemd"

class SystemInfoCgroupVersionEnum(str, Enum):
    EMPTY = ""
    ONE = "1"
    TWO = "2"

LJ = TypeVar("LJ", bound="SystemInfoDefaultAddressPools")

class SystemInfoDefaultAddressPools:
    base: Union[Unset, str] = UNSET
    size: Union[Unset, int] = UNSET

        base = self.base
        size = self.size

        if base is not UNSET:
            field_dict["base"] = base
        if size is not UNSET:
            field_dict["size"] = size

    def from_dict(cls: Type[LJ], src_dict: Dict[str, Any]) -> LJ:
        base = d.pop("base", UNSET)

        size = d.pop("size", UNSET)

        system_info_default_address_pools = cls(
            base=base,
            size=size,
        )

        system_info_default_address_pools.additional_properties = d
        return system_info_default_address_pools

    @property

class SystemInfoIsolationEnum(str, Enum):
    EMPTY = ""
    DEFAULT = "default"
    HYPERV = "hyperv"
    PROCESS = "process"

class UnitAngle(str, Enum):
    """The valid types of angle formats."""  # noqa: E501

    """# Degrees <https://en.wikipedia.org/wiki/Degree_(angle)> """  # noqa: E501
    DEGREES = "degrees"
    """# Radians <https://en.wikipedia.org/wiki/Radian> """  # noqa: E501
    RADIANS = "radians"

from ..models.unit_angle import UnitAngle

TF = TypeVar("TF", bound="UnitAngleConversion")

class UnitAngleConversion:
    """Result of converting between units."""  # noqa: E501

    input: Union[Unset, float] = UNSET
    input_unit: Union[Unset, UnitAngle] = UNSET
    output: Union[Unset, float] = UNSET
    output_unit: Union[Unset, UnitAngle] = UNSET

        if not isinstance(self.input_unit, Unset):
            input_unit = self.input_unit

        if input_unit is not UNSET:
            field_dict["input_unit"] = input_unit

    def from_dict(cls: Type[TF], src_dict: Dict[str, Any]) -> TF:
        else:

        else:

            id = UNSET
        else:

        _input_unit = d.pop("input_unit", UNSET)
        input_unit: Union[Unset, UnitAngle]
        if isinstance(_input_unit, Unset):
            input_unit = UNSET
        else:
            input_unit = _input_unit  # type: ignore[arg-type]

        output_unit: Union[Unset, UnitAngle]
        else:

        else:

        else:

        else:

        unit_angle_conversion = cls(
            id=id,
        )

        unit_angle_conversion.additional_properties = d
        return unit_angle_conversion

    @property

class UnitArea(str, Enum):
    """The valid types of area units."""  # noqa: E501

    """# Square centimetres <https://en.wikipedia.org/wiki/Square_centimetre> """  # noqa: E501
    CM2 = "cm2"
    """# Square decimetres <https://en.wikipedia.org/wiki/Square_decimetre> """  # noqa: E501
    DM2 = "dm2"
    """# Square feet <https://en.wikipedia.org/wiki/Square_foot> """  # noqa: E501
    FT2 = "ft2"
    """# Square inches <https://en.wikipedia.org/wiki/Square_inch> """  # noqa: E501
    IN2 = "in2"
    """# Square kilometres <https://en.wikipedia.org/wiki/Square_kilometre> """  # noqa: E501
    KM2 = "km2"
    """# Square metres <https://en.wikipedia.org/wiki/Square_metre> """  # noqa: E501
    M2 = "m2"
    """# Square millimetres <https://en.wikipedia.org/wiki/Square_millimetre> """  # noqa: E501
    MM2 = "mm2"
    """# Square yards <https://en.wikipedia.org/wiki/Square_mile> """  # noqa: E501
    YD2 = "yd2"

HF = TypeVar("HF", bound="UnitAreaConversion")

class UnitAreaConversion:

    input_unit: Union[Unset, UnitArea] = UNSET

    def from_dict(cls: Type[HF], src_dict: Dict[str, Any]) -> HF:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitArea]
        else:

        else:

        else:

        else:

        else:

        unit_area_conversion = cls(
            id=id,
        )

        unit_area_conversion.additional_properties = d
        return unit_area_conversion

    @property

class UnitCurrent(str, Enum):
    """The valid types of current units."""  # noqa: E501

    """# Amperes <https://en.wikipedia.org/wiki/Ampere> """  # noqa: E501
    AMPERES = "amperes"
    """# Microamperes <https://en.wikipedia.org/wiki/Microampere> """  # noqa: E501
    MICROAMPERES = "microamperes"
    """# Milliamperes <https://en.wikipedia.org/wiki/Milliampere> """  # noqa: E501
    MILLIAMPERES = "milliamperes"
    """# Nanoamperes <https://en.wikipedia.org/wiki/Nanoampere> """  # noqa: E501
    NANOAMPERES = "nanoamperes"

from ..models.unit_current import UnitCurrent

JD = TypeVar("JD", bound="UnitCurrentConversion")

class UnitCurrentConversion:

    input_unit: Union[Unset, UnitCurrent] = UNSET
    output_unit: Union[Unset, UnitCurrent] = UNSET

    def from_dict(cls: Type[JD], src_dict: Dict[str, Any]) -> JD:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitCurrent]
        else:

        output_unit: Union[Unset, UnitCurrent]
        else:

        else:

        else:

        else:

        unit_current_conversion = cls(
            id=id,
        )

        unit_current_conversion.additional_properties = d
        return unit_current_conversion

    @property

class UnitDensity(str, Enum):
    """The valid types for density units."""  # noqa: E501

    """# Pounds per cubic feet. """  # noqa: E501
    LB_FT3 = "lb:ft3"
    """# Kilograms per cubic meter. """  # noqa: E501
    KG_M3 = "kg:m3"

class UnitEnergy(str, Enum):
    """The valid types of energy units."""  # noqa: E501

    """# British Thermal Unit (BTU) <https://en.wikipedia.org/wiki/British_thermal_unit> """  # noqa: E501
    BTU = "btu"
    """# Electron Volts (eV) <https://en.wikipedia.org/wiki/Electronvolt> """  # noqa: E501
    ELECTRONVOLTS = "electronvolts"
    """# Joules (or watt-seconds) <https://en.wikipedia.org/wiki/Joule> """  # noqa: E501
    JOULES = "joules"
    """# Kilocalories (often just called calories) <https://en.wikipedia.org/wiki/Kilocalorie> """  # noqa: E501
    KILOCALORIES = "kilocalories"
    """# Kilowatt hours (kWh) <https://en.wikipedia.org/wiki/Kilowatt-hour> """  # noqa: E501
    KILOWATT_HOURS = "kilowatt_hours"
    """# Watt hours (Wh) <https://en.wikipedia.org/wiki/Kilowatt-hour> """  # noqa: E501
    WATT_HOURS = "watt_hours"

from ..models.unit_energy import UnitEnergy

RZ = TypeVar("RZ", bound="UnitEnergyConversion")

class UnitEnergyConversion:

    input_unit: Union[Unset, UnitEnergy] = UNSET
    output_unit: Union[Unset, UnitEnergy] = UNSET

    def from_dict(cls: Type[RZ], src_dict: Dict[str, Any]) -> RZ:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitEnergy]
        else:

        output_unit: Union[Unset, UnitEnergy]
        else:

        else:

        else:

        else:

        unit_energy_conversion = cls(
            id=id,
        )

        unit_energy_conversion.additional_properties = d
        return unit_energy_conversion

    @property

class UnitForce(str, Enum):
    """The valid types of force units."""  # noqa: E501

    """# Dynes <https://en.wikipedia.org/wiki/Dyne> """  # noqa: E501
    DYNES = "dynes"
    """# Kiloponds <https://en.wikipedia.org/wiki/Kilopond> """  # noqa: E501
    KILOPONDS = "kiloponds"
    """# Micronewtons <https://en.wikipedia.org/wiki/Newton_(unit)> """  # noqa: E501
    MICRONEWTONS = "micronewtons"
    """# Millinewtons <https://en.wikipedia.org/wiki/Newton_(unit)> """  # noqa: E501
    MILLINEWTONS = "millinewtons"
    """# Newtons <https://en.wikipedia.org/wiki/Newton_(unit)> """  # noqa: E501
    NEWTONS = "newtons"
    """# Poundals <https://en.wikipedia.org/wiki/Poundal> """  # noqa: E501
    POUNDALS = "poundals"
    """# Pounds <https://en.wikipedia.org/wiki/Pound_(force)> """  # noqa: E501
    POUNDS = "pounds"

from ..models.unit_force import UnitForce

BH = TypeVar("BH", bound="UnitForceConversion")

class UnitForceConversion:

    input_unit: Union[Unset, UnitForce] = UNSET
    output_unit: Union[Unset, UnitForce] = UNSET

    def from_dict(cls: Type[BH], src_dict: Dict[str, Any]) -> BH:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitForce]
        else:

        output_unit: Union[Unset, UnitForce]
        else:

        else:

        else:

        else:

        unit_force_conversion = cls(
            id=id,
        )

        unit_force_conversion.additional_properties = d
        return unit_force_conversion

    @property

class UnitFrequency(str, Enum):
    """The valid types of frequency units."""  # noqa: E501

    """# Gigahertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    GIGAHERTZ = "gigahertz"
    """# Hertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    HERTZ = "hertz"
    """# Kilohertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    KILOHERTZ = "kilohertz"
    """# Megahertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    MEGAHERTZ = "megahertz"
    """# Microhertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    MICROHERTZ = "microhertz"
    """# Millihertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    MILLIHERTZ = "millihertz"
    """# Nanohertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    NANOHERTZ = "nanohertz"
    """# Terahertz <https://en.wikipedia.org/wiki/Hertz> """  # noqa: E501
    TERAHERTZ = "terahertz"

from ..models.unit_frequency import UnitFrequency

SX = TypeVar("SX", bound="UnitFrequencyConversion")

class UnitFrequencyConversion:

    input_unit: Union[Unset, UnitFrequency] = UNSET
    output_unit: Union[Unset, UnitFrequency] = UNSET

    def from_dict(cls: Type[SX], src_dict: Dict[str, Any]) -> SX:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitFrequency]
        else:

        output_unit: Union[Unset, UnitFrequency]
        else:

        else:

        else:

        else:

        unit_frequency_conversion = cls(
            id=id,
        )

        unit_frequency_conversion.additional_properties = d
        return unit_frequency_conversion

    @property

class UnitLength(str, Enum):
    """The valid types of length units."""  # noqa: E501

    """# Centimetres <https://en.wikipedia.org/wiki/Centimetre> """  # noqa: E501
    CM = "cm"
    """# Feet <https://en.wikipedia.org/wiki/Foot_(unit)> """  # noqa: E501
    FT = "ft"
    """# Inches <https://en.wikipedia.org/wiki/Inch> """  # noqa: E501
    IN = "in"
    """# Metres <https://en.wikipedia.org/wiki/Metre> """  # noqa: E501
    M = "m"
    """# Millimetres <https://en.wikipedia.org/wiki/Millimetre> """  # noqa: E501
    MM = "mm"
    """# Yards <https://en.wikipedia.org/wiki/Yard> """  # noqa: E501
    YD = "yd"

CN = TypeVar("CN", bound="UnitLengthConversion")

class UnitLengthConversion:

    input_unit: Union[Unset, UnitLength] = UNSET

    def from_dict(cls: Type[CN], src_dict: Dict[str, Any]) -> CN:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitLength]
        else:

        else:

        else:

        else:

        else:

        unit_length_conversion = cls(
            id=id,
        )

        unit_length_conversion.additional_properties = d
        return unit_length_conversion

    @property

class UnitMass(str, Enum):
    """The valid types of mass units."""  # noqa: E501

    """# Grams <https://en.wikipedia.org/wiki/Gram> """  # noqa: E501
    G = "g"
    """# Kilograms <https://en.wikipedia.org/wiki/Kilogram> """  # noqa: E501
    KG = "kg"
    """# Pounds <https://en.wikipedia.org/wiki/Pound_(mass)> """  # noqa: E501
    LB = "lb"

GS = TypeVar("GS", bound="UnitMassConversion")

class UnitMassConversion:

    input_unit: Union[Unset, UnitMass] = UNSET

    def from_dict(cls: Type[GS], src_dict: Dict[str, Any]) -> GS:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitMass]
        else:

        else:

        else:

        else:

        else:

        unit_mass_conversion = cls(
            id=id,
        )

        unit_mass_conversion.additional_properties = d
        return unit_mass_conversion

    @property

class UnitPower(str, Enum):
    """The valid types of power units."""  # noqa: E501

    """# British thermal units (BTU) per minute <https://en.wikipedia.org/wiki/British_thermal_unit> """  # noqa: E501
    BTU_PER_MINUTE = "btu_per_minute"
    """# Horsepower (hp) <https://en.wikipedia.org/wiki/Horsepower> """  # noqa: E501
    HORSEPOWER = "horsepower"
    """# Kilowatts <https://en.wikipedia.org/wiki/Kilowatt> """  # noqa: E501
    KILOWATTS = "kilowatts"
    """# Metric horsepower (PS) <https://en.wikipedia.org/wiki/Horsepower#Metric_horsepower> """  # noqa: E501
    METRIC_HORSEPOWER = "metric_horsepower"
    """# Microwatts <https://en.wikipedia.org/wiki/Microwatt> """  # noqa: E501
    MICROWATTS = "microwatts"
    """# Millwatts <https://en.wikipedia.org/wiki/Milliwatt> """  # noqa: E501
    MILLIWATTS = "milliwatts"
    """# Watts <https://en.wikipedia.org/wiki/Watt> """  # noqa: E501
    WATTS = "watts"

from ..models.unit_power import UnitPower

SO = TypeVar("SO", bound="UnitPowerConversion")

class UnitPowerConversion:

    input_unit: Union[Unset, UnitPower] = UNSET
    output_unit: Union[Unset, UnitPower] = UNSET

    def from_dict(cls: Type[SO], src_dict: Dict[str, Any]) -> SO:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitPower]
        else:

        output_unit: Union[Unset, UnitPower]
        else:

        else:

        else:

        else:

        unit_power_conversion = cls(
            id=id,
        )

        unit_power_conversion.additional_properties = d
        return unit_power_conversion

    @property

class UnitPressure(str, Enum):
    """The valid types of pressure units."""  # noqa: E501

    """# Atmospheres <https://en.wikipedia.org/wiki/Standard_atmosphere_(unit)> """  # noqa: E501
    ATMOSPHERES = "atmospheres"
    """# Bars <https://en.wikipedia.org/wiki/Bar_(unit)> """  # noqa: E501
    BARS = "bars"
    """# Hectopascals <https://en.wikipedia.org/wiki/Hectopascal> """  # noqa: E501
    HECTOPASCALS = "hectopascals"
    """# Kilopascals <https://en.wikipedia.org/wiki/Kilopascal> """  # noqa: E501
    KILOPASCALS = "kilopascals"
    """# Millibars <https://en.wikipedia.org/wiki/Bar_(unit)> """  # noqa: E501
    MILLIBARS = "millibars"
    """# Pascals <https://en.wikipedia.org/wiki/Pascal_(unit)> """  # noqa: E501
    PASCALS = "pascals"
    """# Pounds per square inch (PSI) - <https://en.wikipedia.org/wiki/Pound_per_square_inch> """  # noqa: E501
    PSI = "psi"

from ..models.unit_pressure import UnitPressure

ZS = TypeVar("ZS", bound="UnitPressureConversion")

class UnitPressureConversion:

    input_unit: Union[Unset, UnitPressure] = UNSET
    output_unit: Union[Unset, UnitPressure] = UNSET

    def from_dict(cls: Type[ZS], src_dict: Dict[str, Any]) -> ZS:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitPressure]
        else:

        output_unit: Union[Unset, UnitPressure]
        else:

        else:

        else:

        else:

        unit_pressure_conversion = cls(
            id=id,
        )

        unit_pressure_conversion.additional_properties = d
        return unit_pressure_conversion

    @property

class UnitTemperature(str, Enum):
    """The valid types of temperature units."""  # noqa: E501

    """# Celsius <https://en.wikipedia.org/wiki/Celsius> """  # noqa: E501
    CELSIUS = "celsius"
    """# Fahrenheit <https://en.wikipedia.org/wiki/Fahrenheit> """  # noqa: E501
    FAHRENHEIT = "fahrenheit"
    """# Kelvin <https://en.wikipedia.org/wiki/Kelvin> """  # noqa: E501
    KELVIN = "kelvin"
    """# Rankine <https://en.wikipedia.org/wiki/Rankine_scale> """  # noqa: E501
    RANKINE = "rankine"

from ..models.unit_temperature import UnitTemperature

AM = TypeVar("AM", bound="UnitTemperatureConversion")

class UnitTemperatureConversion:

    input_unit: Union[Unset, UnitTemperature] = UNSET
    output_unit: Union[Unset, UnitTemperature] = UNSET

    def from_dict(cls: Type[AM], src_dict: Dict[str, Any]) -> AM:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitTemperature]
        else:

        output_unit: Union[Unset, UnitTemperature]
        else:

        else:

        else:

        else:

        unit_temperature_conversion = cls(
            id=id,
        )

        unit_temperature_conversion.additional_properties = d
        return unit_temperature_conversion

    @property

class UnitTorque(str, Enum):
    """The valid types of torque units."""  # noqa: E501

    """# Newton metres <https://en.wikipedia.org/wiki/Newton_metre> """  # noqa: E501
    NEWTON_METRES = "newton_metres"
    """# Pound foot <https://en.wikipedia.org/wiki/Pound-foot_(torque)> """  # noqa: E501
    POUND_FOOT = "pound_foot"

from ..models.unit_torque import UnitTorque

GK = TypeVar("GK", bound="UnitTorqueConversion")

class UnitTorqueConversion:

    input_unit: Union[Unset, UnitTorque] = UNSET
    output_unit: Union[Unset, UnitTorque] = UNSET

    def from_dict(cls: Type[GK], src_dict: Dict[str, Any]) -> GK:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitTorque]
        else:

        output_unit: Union[Unset, UnitTorque]
        else:

        else:

        else:

        else:

        unit_torque_conversion = cls(
            id=id,
        )

        unit_torque_conversion.additional_properties = d
        return unit_torque_conversion

    @property

class UnitVolume(str, Enum):
    """The valid types of volume units."""  # noqa: E501

    """# Cubic centimetres (cc or cm³) <https://en.wikipedia.org/wiki/Cubic_centimetre> """  # noqa: E501
    CM3 = "cm3"
    """# Cubic feet (ft³) <https://en.wikipedia.org/wiki/Cubic_foot> """  # noqa: E501
    FT3 = "ft3"
    """# Cubic inches (cu in or in³) <https://en.wikipedia.org/wiki/Cubic_inch> """  # noqa: E501
    IN3 = "in3"
    """# Cubic metres (m³) <https://en.wikipedia.org/wiki/Cubic_metre> """  # noqa: E501
    M3 = "m3"
    """# Cubic yards (yd³) <https://en.wikipedia.org/wiki/Cubic_yard> """  # noqa: E501
    YD3 = "yd3"
    """# US Fluid Ounces (fl oz) <https://en.wikipedia.org/wiki/Fluid_ounce> """  # noqa: E501
    USFLOZ = "usfloz"
    """# US Gallons (gal US) <https://en.wikipedia.org/wiki/Gallon> """  # noqa: E501
    USGAL = "usgal"
    """# Liters (l) <https://en.wikipedia.org/wiki/Litre> """  # noqa: E501
    L = "l"
    """# Milliliters (ml) <https://en.wikipedia.org/wiki/Litre> """  # noqa: E501
    ML = "ml"

SG = TypeVar("SG", bound="UnitVolumeConversion")

class UnitVolumeConversion:

    input_unit: Union[Unset, UnitVolume] = UNSET

    def from_dict(cls: Type[SG], src_dict: Dict[str, Any]) -> SG:
        else:

        else:

            id = UNSET
        else:

        input_unit: Union[Unset, UnitVolume]
        else:

        else:

        else:

        else:

        else:

        unit_volume_conversion = cls(
            id=id,
        )

        unit_volume_conversion.additional_properties = d
        return unit_volume_conversion

    @property

QZ = TypeVar("QZ", bound="UpdateUser")

class UpdateUser:
    """The user-modifiable parts of a User."""  # noqa: E501

    def from_dict(cls: Type[QZ], src_dict: Dict[str, Any]) -> QZ:

        update_user = cls(
        )

        update_user.additional_properties = d
        return update_user

    @property

SY = TypeVar("SY", bound="User")

class User:
    """A user."""  # noqa: E501

    def from_dict(cls: Type[SY], src_dict: Dict[str, Any]) -> SY:

        else:

        else:

        else:

        user = cls(
            id=id,
        )

        user.additional_properties = d
        return user

    @property

YK = TypeVar("YK", bound="UserResultsPage")

class UserResultsPage:

    from ..models.user import User

    items: Union[Unset, List[User]] = UNSET

        from ..models.user import User

        items: Union[Unset, List[User]] = UNSET

    def from_dict(cls: Type[YK], src_dict: Dict[str, Any]) -> YK:

        items = cast(List[User], d.pop("items", UNSET))

        user_results_page = cls(
        )

        user_results_page.additional_properties = d
        return user_results_page

    @property

class Uuid(str):

WS = TypeVar("WS", bound="VerificationToken")

class VerificationToken:
    """A verification token for a user.

    This is typically used to verify a user's email address."""  # noqa: E501

    identifier: Union[Unset, str] = UNSET

        identifier = self.identifier

        if identifier is not UNSET:
            field_dict["identifier"] = identifier

    def from_dict(cls: Type[WS], src_dict: Dict[str, Any]) -> WS:
        else:

        else:

        identifier = d.pop("identifier", UNSET)

        else:

        verification_token = cls(
            id=id,
            identifier=identifier,
        )

        verification_token.additional_properties = d
        return verification_token

    @property

""" Contains some shared types for properties """
from typing import (
    BinaryIO,
    Generic,
    MutableMapping,
    Optional,
    TextIO,
    Tuple,
    TypeVar,
    Union,
)

class Unset:
    def __bool__(self) -> bool:
        return False

UNSET: Unset = Unset()

FileJsonType = Tuple[Optional[str], Union[BinaryIO, TextIO], Optional[str]]

class File:
    """Contains information for file uploads"""

    payload: Union[BinaryIO, TextIO]
    file_name: Optional[str] = None
    mime_type: Optional[str] = None

    def to_tuple(self) -> FileJsonType:
        """Return a tuple representation that httpx will accept for multipart/form-data"""  # noqa: E501
        return self.file_name, self.payload, self.mime_type

T = TypeVar("T")

class Response(Generic[T]):
    """A response from an endpoint"""  # noqa: E501

    status_code: int
    content: bytes
    headers: MutableMapping[str, str]
    parsed: Optional[T]

__all__ = ["File", "Response", "FileJsonType"]