ByoungSooPark/kittycad.py
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update files

Browse Source 
Signed-off-by: Jess Frazelle <github@jessfraz.com>
This commit is contained in:
Jess Frazelle
2022-04-06 21:14:12 -07:00
parent 17b517dd5a
commit 15d5bf50c1
39 changed files with 1057 additions and 2236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/build-test.yml vendored
View File

@ -47,7 +47,7 @@ jobs:
# stop the build if there are Python syntax errors or undefined names
poetry run flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
# exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
poetry run flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
#poetry run flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
- name: Run pytest
shell: bash

14
generate/generate.py
View File

@ -114,7 +114,7 @@ def generatePath(
success_type = endoint_refs[0]
if fn_name == 'file_conversion_status' or fn_name == 'post_file_conversion':
if fn_name == 'get_file_conversion' or fn_name == 'create_file_conversion':
fn_name += '_with_base64_helper'
# Iterate over the parameters.
@ -1048,9 +1048,19 @@ def generateType(path: str, name: str, schema: dict):
f.write("\n")
f.write("\tdef __str__(self) -> str:\n")
f.write("\t\treturn str(self.value)\n")
elif type_name == 'integer':
f.write("class " + name + "(int):\n")
f.write("\n")
f.write("\tdef __int__(self) -> int:\n")
f.write("\t\treturn self\n")
elif type_name == 'string':
f.write("class " + name + "(str):\n")
f.write("\n")
f.write("\tdef __str__(self) -> str:\n")
f.write("\t\treturn self\n")
else:
print(" unsupported type: ", type_name)
return
raise Exception(" unsupported type: ", type_name)
# Close the file.
f.close()

1
kittycad/api/beta/__init__.py
View File

@ -1 +0,0 @@
""" Contains methods for accessing the beta API paths: Beta API endpoints. """

30
kittycad/api/file/post_file_conversion_with_base64_helper.py → kittycad/api/file/create_file_conversion_with_base64_helper.py
View File

@ -4,56 +4,56 @@ import base64
import httpx
from ...client import Client
from ...models.error_message import ErrorMessage
from ...models.file_conversion import FileConversion
from ...models.valid_source_file_format import ValidSourceFileFormat
from ...models.valid_output_file_format import ValidOutputFileFormat
from ...models import Error
from ...models import FileConversionWithOutput
from ...models import FileConversionSourceFormat
from ...models import FileConversionOutputFormat
from ...types import Response
from ...api.file.post_file_conversion import sync as fc_sync, asyncio as fc_asyncio
from ...api.file.create_file_conversion import sync as fc_sync, asyncio as fc_asyncio
def sync(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
src_format: FileConversionSourceFormat,
output_format: FileConversionOutputFormat,
body: bytes,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
) -> Optional[Union[Any, FileConversionWithOutput, 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(
source_format=source_format,
src_format=src_format,
output_format=output_format,
body=encoded,
client=client,
)
if isinstance(fc, FileConversion) and fc.output != "":
if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output)
return fc
async def asyncio(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
src_format: FileConversionSourceFormat,
output_format: FileConversionOutputFormat,
body: bytes,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
) -> Optional[Union[Any, FileConversionWithOutput, 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 = await fc_asyncio(
source_format=source_format,
src_format=src_format,
output_format=output_format,
body=encoded,
client=client,
)
if isinstance(fc, FileConversion) and fc.output != "":
if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output)
return fc

118
kittycad/api/file/file_conversion_status.py
View File

@ -1,118 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.file_conversion import FileConversion
from ...models.error_message import ErrorMessage
from ...types import Response
def _get_kwargs(
id: str,
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/file/conversion/{id}".format(client.base_url, id=id)
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(),
}
def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
if response.status_code == 200:
response_200 = FileConversion.from_dict(response.json())
return response_200
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
if response.status_code == 404:
response_404 = ErrorMessage.from_dict(response.json())
return response_404
if response.status_code == 406:
response_406 = ErrorMessage.from_dict(response.json())
return response_406
if response.status_code == 500:
response_500 = ErrorMessage.from_dict(response.json())
return response_500
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, FileConversion, ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
id: str,
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
id=id,
client=client,
)
response = httpx.get(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
id: str,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Get the status and output of an async file conversion. """
return sync_detailed(
id=id,
client=client,
).parsed
async def asyncio_detailed(
id: str,
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
id=id,
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.get(**kwargs)
return _build_response(response=response)
async def asyncio(
id: str,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Get the status and output of an async file conversion. """
return (
await asyncio_detailed(
id=id,
client=client,
)
).parsed

14
kittycad/api/file/file_conversion_status_with_base64_helper.py → kittycad/api/file/get_file_conversion_with_base64_helper.py
View File

@ -4,17 +4,17 @@ import base64
import httpx
from ...client import Client
from ...models.error_message import ErrorMessage
from ...models.file_conversion import FileConversion
from ...models import Error
from ...models.file_conversion import FileConversionWithOutput
from ...types import Response
from ...api.file.file_conversion_status import sync as fc_sync, asyncio as fc_asyncio
from ...api.file.get_file_conversion import sync as fc_sync, asyncio as fc_asyncio
def sync(
id: str,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
) -> Optional[Union[Any, FileConversionWithOutput, Error]]:
"""Get the status of a file conversion. This function automatically base64 decodes the output response if there is one."""
fc = fc_sync(
@ -22,7 +22,7 @@ def sync(
client=client,
)
if isinstance(fc, FileConversion) and fc.output != "":
if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output)
return fc
@ -32,7 +32,7 @@ async def asyncio(
id: str,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
) -> Optional[Union[Any, FileConversionWithOutput, Error]]:
"""Get the status of a file conversion. This function automatically base64 decodes the output response if there is one."""
fc = await fc_asyncio(
@ -40,7 +40,7 @@ async def asyncio(
client=client,
)
if isinstance(fc, FileConversion) and fc.output != "":
if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output)
return fc

142
kittycad/api/file/post_file_conversion.py
View File

@ -1,142 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.file_conversion import FileConversion
from ...models.error_message import ErrorMessage
from ...models.valid_source_file_format import ValidSourceFileFormat
from ...models.valid_output_file_format import ValidOutputFileFormat
from ...types import Response
def _get_kwargs(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
body: bytes,
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/file/conversion/{sourceFormat}/{outputFormat}".format(client.base_url, sourceFormat=source_format, outputFormat=output_format)
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[Any, FileConversion, ErrorMessage]]:
if response.status_code == 200:
response_200 = FileConversion.from_dict(response.json())
return response_200
if response.status_code == 202:
response_202 = FileConversion.from_dict(response.json())
return response_202
if response.status_code == 400:
response_400 = ErrorMessage.from_dict(response.json())
return response_400
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
if response.status_code == 406:
response_406 = ErrorMessage.from_dict(response.json())
return response_406
if response.status_code == 500:
response_500 = ErrorMessage.from_dict(response.json())
return response_500
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, FileConversion, ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
body: bytes,
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
source_format=source_format,
output_format=output_format,
body=body,
client=client,
)
response = httpx.post(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
body: bytes,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Convert a CAD file from one format to another. If the file being converted is larger than 30MB, it will be performed asynchronously. """
return sync_detailed(
source_format=source_format,
output_format=output_format,
body=body,
client=client,
).parsed
async def asyncio_detailed(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
body: bytes,
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
source_format=source_format,
output_format=output_format,
body=body,
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.post(**kwargs)
return _build_response(response=response)
async def asyncio(
source_format: ValidSourceFileFormat,
output_format: ValidOutputFileFormat,
body: bytes,
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Convert a CAD file from one format to another. If the file being converted is larger than 30MB, it will be performed asynchronously. """
return (
await asyncio_detailed(
source_format=source_format,
output_format=output_format,
body=body,
client=client,
)
).parsed

1
kittycad/api/internal/__init__.py
View File

@ -1 +0,0 @@
""" Contains methods for accessing the internal API paths: Internal API endpoints. """

103
kittycad/api/internal/gpu_devices.py
View File

@ -1,103 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.gpu_device import GPUDevice
from ...models.error_message import ErrorMessage
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/_internal/gpu/devices".format(client.base_url)
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(),
}
def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, [GPUDevice], ErrorMessage]]:
if response.status_code == 200:
response_200 = [
GPUDevice.from_dict(item)
for item in response.json()
]
return response_200
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, [GPUDevice], ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[Union[Any, [GPUDevice], ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
response = httpx.get(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[Union[Any, [GPUDevice], ErrorMessage]]:
""" Get information about GPU devices on this server. This is primarily used for debugging. This endpoint can only be used by specific KittyCAD employees. """
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[Union[Any, [GPUDevice], ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.get(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[Union[Any, [GPUDevice], ErrorMessage]]:
""" Get information about GPU devices on this server. This is primarily used for debugging. This endpoint can only be used by specific KittyCAD employees. """
return (
await asyncio_detailed(
client=client,
)
).parsed

103
kittycad/api/internal/stop_async_conversions.py
View File

@ -1,103 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.file_conversion import FileConversion
from ...models.error_message import ErrorMessage
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/_internal/async/conversions/stop".format(client.base_url)
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(),
}
def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
if response.status_code == 200:
response_200 = FileConversion.from_dict(response.json())
return response_200
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
if response.status_code == 404:
response_404 = ErrorMessage.from_dict(response.json())
return response_404
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, FileConversion, ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
response = httpx.post(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Stop all async conversions that are currently running. This endpoint can only be used by specific KittyCAD employees. """
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[Union[Any, FileConversion, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.post(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[Union[Any, FileConversion, ErrorMessage]]:
""" Stop all async conversions that are currently running. This endpoint can only be used by specific KittyCAD employees. """
return (
await asyncio_detailed(
client=client,
)
).parsed

100
kittycad/api/meta/auth_session.py
View File

@ -1,100 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.auth_session import AuthSession
from ...models.error_message import ErrorMessage
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/_meta/debug/session".format(client.base_url)
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(),
}
def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, AuthSession, ErrorMessage]]:
if response.status_code == 200:
response_200 = AuthSession.from_dict(response.json())
return response_200
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, AuthSession, ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[Union[Any, AuthSession, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
response = httpx.get(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[Union[Any, AuthSession, ErrorMessage]]:
""" Get information about your API request session. This is primarily used for debugging. """
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[Union[Any, AuthSession, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.get(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[Union[Any, AuthSession, ErrorMessage]]:
""" Get information about your API request session. This is primarily used for debugging. """
return (
await asyncio_detailed(
client=client,
)
).parsed

100
kittycad/api/meta/instance_metadata.py
View File

@ -1,100 +0,0 @@
from typing import Any, Dict, Optional, Union
import httpx
from ...client import Client
from ...models.instance import Instance
from ...models.error_message import ErrorMessage
from ...types import Response
def _get_kwargs(
*,
client: Client,
) -> Dict[str, Any]:
url = "{}/_meta/debug/instance".format(client.base_url)
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(),
}
def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, Instance, ErrorMessage]]:
if response.status_code == 200:
response_200 = Instance.from_dict(response.json())
return response_200
if response.status_code == 401:
response_401 = ErrorMessage.from_dict(response.json())
return response_401
if response.status_code == 403:
response_403 = ErrorMessage.from_dict(response.json())
return response_403
return None
def _build_response(*, response: httpx.Response) -> Response[Union[Any, Instance, ErrorMessage]]:
return Response(
status_code=response.status_code,
content=response.content,
headers=response.headers,
parsed=_parse_response(response=response),
)
def sync_detailed(
*,
client: Client,
) -> Response[Union[Any, Instance, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
response = httpx.get(
verify=client.verify_ssl,
**kwargs,
)
return _build_response(response=response)
def sync(
*,
client: Client,
) -> Optional[Union[Any, Instance, ErrorMessage]]:
""" Get information about this specific API server instance. This is primarily used for debugging. """
return sync_detailed(
client=client,
).parsed
async def asyncio_detailed(
*,
client: Client,
) -> Response[Union[Any, Instance, ErrorMessage]]:
kwargs = _get_kwargs(
client=client,
)
async with httpx.AsyncClient(verify=client.verify_ssl) as _client:
response = await _client.get(**kwargs)
return _build_response(response=response)
async def asyncio(
*,
client: Client,
) -> Optional[Union[Any, Instance, ErrorMessage]]:
""" Get information about this specific API server instance. This is primarily used for debugging. """
return (
await asyncio_detailed(
client=client,
)
).parsed

48
kittycad/client_test.py
View File

@ -3,9 +3,10 @@ import pytest
import asyncio
from .client import ClientFromEnv
from .models import FileConversion, ValidOutputFileFormat, ValidSourceFileFormat, AuthSession, Instance, PongMessage, FileConversionStatus
from .api.file import post_file_conversion_with_base64_helper
from .api.meta import auth_session, instance_metadata, ping
from .models import FileConversion, FileConversionOutputFormat, FileConversionSourceFormat, User, Pong, FileConversionStatus
from .api.file import create_file_conversion_with_base64_helper
from .api.meta import ping
from .api.users import get_user_self
def test_get_session():
@ -13,7 +14,7 @@ def test_get_session():
client = ClientFromEnv()
# Get the session.
session: AuthSession = auth_session.sync(client=client)
session: User = get_user_self.sync(client=client)
assert session is not None
@ -26,44 +27,19 @@ async def test_get_session_async():
client = ClientFromEnv()
# Get the session.
session: AuthSession = await auth_session.asyncio(client=client)
session: User = await get_user_self.asyncio(client=client)
assert session is not None
print(f"Session: {session}")
def test_get_instance():
# Create our client.
client = ClientFromEnv()
# Get the instance.
instance: Instance = instance_metadata.sync(client=client)
assert instance is not None
print(f"Instance: {instance}")
@pytest.mark.asyncio
async def test_get_instance_async():
# Create our client.
client = ClientFromEnv()
# Get the instance.
instance: Instance = await instance_metadata.asyncio(client=client)
assert instance is not None
print(f"Instance: {instance}")
def test_ping():
# Create our client.
client = ClientFromEnv()
# Get the message.
message: PongMessage = ping.sync(client=client)
message: Pong = ping.sync(client=client)
assert message is not None
@ -76,7 +52,7 @@ async def test_ping_async():
client = ClientFromEnv()
# Get the message.
message: PongMessage = await ping.asyncio(client=client)
message: Pong = await ping.asyncio(client=client)
assert message is not None
@ -93,11 +69,11 @@ def test_file_convert_stl():
file.close()
# Get the fc.
fc: FileConversion = post_file_conversion_with_base64_helper.sync(
fc: FileConversion = create_file_conversion_with_base64_helper.sync(
client=client,
body=content,
source_format=ValidSourceFileFormat.STL,
output_format=ValidOutputFileFormat.OBJ)
src_format=FileConversionSourceFormat.STL,
output_format=FileConversionOutputFormat.OBJ)
assert fc is not None
@ -121,7 +97,7 @@ async def test_file_convert_stl_async():
file.close()
# Get the fc.
fc: FileConversion = await post_file_conversion_with_base64_helper.asyncio(client=client, body=content, source_format=ValidSourceFileFormat.STL, output_format=ValidOutputFileFormat.OBJ)
fc: FileConversion = await create_file_conversion_with_base64_helper.asyncio(client=client, body=content, src_format=FileConversionSourceFormat.STL, output_format=FileConversionOutputFormat.OBJ)
assert fc is not None

6
kittycad/models/api_call_query_group.py
View File

@ -6,7 +6,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ApiCallQueryGroup")
@attr.s(auto_attribs=True)
class ApiCallQueryGroup:
""" """
@ -36,9 +35,10 @@ class ApiCallQueryGroup:
query = d.pop("query", UNSET)
api_call_query_group = cls(
count=count,
query=query,
count= count,
query= query,
)
api_call_query_group.additional_properties = d

1
kittycad/models/api_call_query_group_by.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class ApiCallQueryGroupBy(str, Enum):
EMAIL = 'email'
METHOD = 'method'

44
kittycad/models/api_call_with_price.py
View File

@ -11,7 +11,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ApiCallWithPrice")
@attr.s(auto_attribs=True)
class ApiCallWithPrice:
""" """
@ -211,28 +210,29 @@ class ApiCallWithPrice:
user_id = d.pop("user_id", UNSET)
api_call_with_price = cls(
completed_at=completed_at,
created_at=created_at,
duration=duration,
email=email,
endpoint=endpoint,
id=id,
ip_address=ip_address,
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,
token=token,
updated_at=updated_at,
user_agent=user_agent,
user_id=user_id,
completed_at= completed_at,
created_at= created_at,
duration= duration,
email= email,
endpoint= endpoint,
id= id,
ip_address= ip_address,
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,
token= token,
updated_at= updated_at,
user_agent= user_agent,
user_id= user_id,
)
api_call_with_price.additional_properties = d

14
kittycad/models/api_token.py
View File

@ -9,7 +9,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ApiToken")
@attr.s(auto_attribs=True)
class ApiToken:
""" """
@ -84,13 +83,14 @@ class ApiToken:
user_id = d.pop("user_id", UNSET)
api_token = cls(
created_at=created_at,
id=id,
is_valid=is_valid,
token=token,
updated_at=updated_at,
user_id=user_id,
created_at= created_at,
id= id,
is_valid= is_valid,
token= token,
updated_at= updated_at,
user_id= user_id,
)
api_token.additional_properties = d

112
kittycad/models/auth_session.py
View File

@ -1,112 +0,0 @@
import datetime
from typing import Any, Dict, List, Type, TypeVar, Union
import attr
from dateutil.parser import isoparse
from ..types import UNSET, Unset
T = TypeVar("T", bound="AuthSession")
@attr.s(auto_attribs=True)
class AuthSession:
""" """
created_at: Union[Unset, datetime.datetime] = UNSET
email: Union[Unset, str] = UNSET
id: Union[Unset, str] = UNSET
image: Union[Unset, str] = UNSET
ip_address: Union[Unset, str] = UNSET
is_valid: Union[Unset, bool] = False
token: Union[Unset, str] = UNSET
user_id: Union[Unset, str] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
created_at: Union[Unset, str] = UNSET
if not isinstance(self.created_at, Unset):
created_at = self.created_at.isoformat()
email = self.email
id = self.id
image = self.image
ip_address = self.ip_address
is_valid = self.is_valid
token = self.token
user_id = self.user_id
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({})
if created_at is not UNSET:
field_dict['created_at'] = created_at
if email is not UNSET:
field_dict['email'] = email
if id is not UNSET:
field_dict['id'] = id
if image is not UNSET:
field_dict['image'] = image
if ip_address is not UNSET:
field_dict['ip_address'] = ip_address
if is_valid is not UNSET:
field_dict['is_valid'] = is_valid
if token is not UNSET:
field_dict['token'] = token
if user_id is not UNSET:
field_dict['user_id'] = user_id
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
_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)
email = d.pop("email", UNSET)
id = d.pop("id", UNSET)
image = d.pop("image", UNSET)
ip_address = d.pop("ip_address", UNSET)
is_valid = d.pop("is_valid", UNSET)
token = d.pop("token", UNSET)
user_id = d.pop("user_id", UNSET)
auth_session = cls(
created_at=created_at,
email=email,
id=id,
image=image,
ip_address=ip_address,
is_valid=is_valid,
token=token,
user_id=user_id,
)
auth_session.additional_properties = d
return auth_session
@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

1
kittycad/models/created_at_sort_mode.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class CreatedAtSortMode(str, Enum):
CREATED_AT_ASCENDING = 'created-at-ascending'
CREATED_AT_DESCENDING = 'created-at-descending'

8
kittycad/models/error.py
View File

@ -6,7 +6,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="Error")
@attr.s(auto_attribs=True)
class Error:
""" """
@ -42,10 +41,11 @@ class Error:
request_id = d.pop("request_id", UNSET)
error = cls(
error_code=error_code,
message=message,
request_id=request_id,
error_code= error_code,
message= message,
request_id= request_id,
)
error.additional_properties = d

68
kittycad/models/error_message.py
View File

@ -1,68 +0,0 @@
from typing import Any, Dict, List, Type, TypeVar, Union
import attr
from ..types import UNSET, Unset
T = TypeVar("T", bound="ErrorMessage")
@attr.s(auto_attribs=True)
class ErrorMessage:
""" """
code: Union[Unset, int] = UNSET
message: Union[Unset, str] = UNSET
status: Union[Unset, str] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
code = self.code
message = self.message
status = self.status
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({})
if code is not UNSET:
field_dict['code'] = code
if message is not UNSET:
field_dict['message'] = message
if status is not UNSET:
field_dict['status'] = status
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
code = d.pop("code", UNSET)
message = d.pop("message", UNSET)
status = d.pop("status", UNSET)
error_message = cls(
code=code,
message=message,
status=status,
)
error_message.additional_properties = d
return error_message
@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

34
kittycad/models/extended_user.py
View File

@ -8,7 +8,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ExtendedUser")
@attr.s(auto_attribs=True)
class ExtendedUser:
""" """
@ -143,23 +142,24 @@ class ExtendedUser:
zendesk_id = d.pop("zendesk_id", UNSET)
extended_user = cls(
company=company,
created_at=created_at,
discord=discord,
email=email,
email_verified=email_verified,
first_name=first_name,
github=github,
id=id,
image=image,
last_name=last_name,
mailchimp_id=mailchimp_id,
name=name,
phone=phone,
stripe_id=stripe_id,
updated_at=updated_at,
zendesk_id=zendesk_id,
company= company,
created_at= created_at,
discord= discord,
email= email,
email_verified= email_verified,
first_name= first_name,
github= github,
id= id,
image= image,
last_name= last_name,
mailchimp_id= mailchimp_id,
name= name,
phone= phone,
stripe_id= stripe_id,
updated_at= updated_at,
zendesk_id= zendesk_id,
)
extended_user.additional_properties = d

26
kittycad/models/file_conversion.py
View File

@ -12,7 +12,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="FileConversion")
@attr.s(auto_attribs=True)
class FileConversion:
""" """
@ -158,19 +157,20 @@ class FileConversion:
worker = d.pop("worker", UNSET)
file_conversion = cls(
completed_at=completed_at,
created_at=created_at,
id=id,
output_file_link=output_file_link,
output_format=output_format,
src_file_link=src_file_link,
src_format=src_format,
started_at=started_at,
status=status,
updated_at=updated_at,
user_id=user_id,
worker=worker,
completed_at= completed_at,
created_at= created_at,
id= id,
output_file_link= output_file_link,
output_format= output_format,
src_file_link= src_file_link,
src_format= src_format,
started_at= started_at,
status= status,
updated_at= updated_at,
user_id= user_id,
worker= worker,
)
file_conversion.additional_properties = d

1
kittycad/models/file_conversion_output_format.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class FileConversionOutputFormat(str, Enum):
STL = 'stl'
OBJ = 'obj'

1
kittycad/models/file_conversion_source_format.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class FileConversionSourceFormat(str, Enum):
STL = 'stl'
OBJ = 'obj'

1
kittycad/models/file_conversion_status.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class FileConversionStatus(str, Enum):
QUEUED = 'Queued'
UPLOADED = 'Uploaded'

20
kittycad/models/file_conversion_with_output.py
View File

@ -12,7 +12,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="FileConversionWithOutput")
@attr.s(auto_attribs=True)
class FileConversionWithOutput:
""" """
@ -133,16 +132,17 @@ class FileConversionWithOutput:
user_id = d.pop("user_id", UNSET)
file_conversion_with_output = cls(
completed_at=completed_at,
created_at=created_at,
id=id,
output=output,
output_format=output_format,
src_format=src_format,
started_at=started_at,
status=status,
user_id=user_id,
completed_at= completed_at,
created_at= created_at,
id= id,
output= output,
output_format= output_format,
src_format= src_format,
started_at= started_at,
status= status,
user_id= user_id,
)
file_conversion_with_output.additional_properties = d

82
kittycad/models/gpu_device.py
View File

@ -1,82 +0,0 @@
from typing import Any, Dict, List, Type, TypeVar, Union
import attr
from ..types import UNSET, Unset
T = TypeVar("T", bound="GPUDevice")
@attr.s(auto_attribs=True)
class GPUDevice:
""" """
id: Union[Unset, int] = UNSET
memory_bus_width: Union[Unset, int] = UNSET
memory_clock_rate: Union[Unset, int] = UNSET
name: Union[Unset, str] = UNSET
peak_memory_bandwidth: Union[Unset, int] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
id = self.id
memory_bus_width = self.memory_bus_width
memory_clock_rate = self.memory_clock_rate
name = self.name
peak_memory_bandwidth = self.peak_memory_bandwidth
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({})
if id is not UNSET:
field_dict['id'] = id
if memory_bus_width is not UNSET:
field_dict['memory_bus_width'] = memory_bus_width
if memory_clock_rate is not UNSET:
field_dict['memory_clock_rate'] = memory_clock_rate
if name is not UNSET:
field_dict['name'] = name
if peak_memory_bandwidth is not UNSET:
field_dict['peak_memory_bandwidth'] = peak_memory_bandwidth
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
id = d.pop("id", UNSET)
memory_bus_width = d.pop("memory_bus_width", UNSET)
memory_clock_rate = d.pop("memory_clock_rate", UNSET)
name = d.pop("name", UNSET)
peak_memory_bandwidth = d.pop("peak_memory_bandwidth", UNSET)
gpu_device = cls(
id=id,
memory_bus_width=memory_bus_width,
memory_clock_rate=memory_clock_rate,
name=name,
peak_memory_bandwidth=peak_memory_bandwidth,
)
gpu_device.additional_properties = d
return gpu_device
@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

132
kittycad/models/instance.py
View File

@ -1,132 +0,0 @@
from typing import Any, Dict, List, Type, TypeVar, Union
import attr
from ..models.server_env import ServerEnv
from ..types import UNSET, Unset
T = TypeVar("T", bound="Instance")
@attr.s(auto_attribs=True)
class Instance:
""" """
cpu_platform: Union[Unset, str] = UNSET
description: Union[Unset, str] = UNSET
environment: Union[Unset, ServerEnv] = UNSET
git_hash: Union[Unset, str] = UNSET
hostname: Union[Unset, str] = UNSET
id: Union[Unset, str] = UNSET
image: Union[Unset, str] = UNSET
ip_address: Union[Unset, str] = UNSET
machine_type: Union[Unset, str] = UNSET
name: Union[Unset, str] = UNSET
zone: Union[Unset, str] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
cpu_platform = self.cpu_platform
description = self.description
environment: Union[Unset, str] = UNSET
if not isinstance(self.environment, Unset):
environment = self.environment.value
git_hash = self.git_hash
hostname = self.hostname
id = self.id
image = self.image
ip_address = self.ip_address
machine_type = self.machine_type
name = self.name
zone = self.zone
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({})
if cpu_platform is not UNSET:
field_dict['cpu_platform'] = cpu_platform
if description is not UNSET:
field_dict['description'] = description
if environment is not UNSET:
field_dict['environment'] = environment
if git_hash is not UNSET:
field_dict['git_hash'] = git_hash
if hostname is not UNSET:
field_dict['hostname'] = hostname
if id is not UNSET:
field_dict['id'] = id
if image is not UNSET:
field_dict['image'] = image
if ip_address is not UNSET:
field_dict['ip_address'] = ip_address
if machine_type is not UNSET:
field_dict['machine_type'] = machine_type
if name is not UNSET:
field_dict['name'] = name
if zone is not UNSET:
field_dict['zone'] = zone
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
cpu_platform = d.pop("cpu_platform", UNSET)
description = d.pop("description", UNSET)
_environment = d.pop("environment", UNSET)
environment: Union[Unset, ServerEnv]
if isinstance(_environment, Unset):
environment = UNSET
else:
environment = ServerEnv(_environment)
git_hash = d.pop("git_hash", UNSET)
hostname = d.pop("hostname", UNSET)
id = d.pop("id", UNSET)
image = d.pop("image", UNSET)
ip_address = d.pop("ip_address", UNSET)
machine_type = d.pop("machine_type", UNSET)
name = d.pop("name", UNSET)
zone = d.pop("zone", UNSET)
instance = cls(
cpu_platform=cpu_platform,
description=description,
environment=environment,
git_hash=git_hash,
hostname=hostname,
id=id,
image=image,
ip_address=ip_address,
machine_type=machine_type,
name=name,
zone=zone,
)
instance.additional_properties = d
return instance
@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

1
kittycad/models/method.py
View File

@ -1,6 +1,5 @@
from enum import Enum
class Method(str, Enum):
OPTIONS = 'OPTIONS'
GET = 'GET'

4
kittycad/models/pong.py
View File

@ -6,7 +6,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="Pong")
@attr.s(auto_attribs=True)
class Pong:
""" """
@ -30,8 +29,9 @@ class Pong:
d = src_dict.copy()
message = d.pop("message", UNSET)
pong = cls(
message=message,
message= message,
)
pong.additional_properties = d

8
kittycad/models/pong_enum.py
View File

@ -1,8 +0,0 @@
from enum import Enum
class PongEnum(str, Enum):
PONG = 'pong'
def __str__(self) -> str:
return str(self.value)

62
kittycad/models/pong_message.py
View File

@ -1,62 +0,0 @@
from typing import Any, Dict, List, Type, TypeVar, Union
import attr
from ..models.pong_enum import PongEnum
from ..types import UNSET, Unset
T = TypeVar("T", bound="PongMessage")
@attr.s(auto_attribs=True)
class PongMessage:
""" """
message: Union[Unset, PongEnum] = UNSET
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
message: Union[Unset, str] = UNSET
if not isinstance(self.message, Unset):
message = self.message.value
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({})
if message is not UNSET:
field_dict['message'] = message
return field_dict
@classmethod
def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
d = src_dict.copy()
_message = d.pop("message", UNSET)
message: Union[Unset, PongEnum]
if isinstance(_message, Unset):
message = UNSET
else:
message = PongEnum(_message)
pong_message = cls(
message=message,
)
pong_message.additional_properties = d
return pong_message
@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

10
kittycad/models/server_env.py
View File

@ -1,10 +0,0 @@
from enum import Enum
class ServerEnv(str, Enum):
PRODUCTION = 'production'
DEVELOPMENT = 'development'
PREVIEW = 'preview'
def __str__(self) -> str:
return str(self.value)

4
kittycad/models/status_code.py
View File

@ -0,0 +1,4 @@
class StatusCode(int):
def __int__(self) -> int:
return self

28
kittycad/models/user.py
View File

@ -8,7 +8,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="User")
@attr.s(auto_attribs=True)
class User:
""" """
@ -125,20 +124,21 @@ class User:
else:
updated_at = isoparse(_updated_at)
user = cls(
company=company,
created_at=created_at,
discord=discord,
email=email,
email_verified=email_verified,
first_name=first_name,
github=github,
id=id,
image=image,
last_name=last_name,
name=name,
phone=phone,
updated_at=updated_at,
company= company,
created_at= created_at,
discord= discord,
email= email,
email_verified= email_verified,
first_name= first_name,
github= github,
id= id,
image= image,
last_name= last_name,
name= name,
phone= phone,
updated_at= updated_at,
)
user.additional_properties = d

4
kittycad/models/uuid.py
View File

@ -0,0 +1,4 @@
class Uuid(str):
def __str__(self) -> str:
return self

13
kittycad/models/valid_output_file_format.py
View File

@ -1,13 +0,0 @@
from enum import Enum
class ValidOutputFileFormat(str, Enum):
STL = 'stl'
OBJ = 'obj'
DAE = 'dae'
STEP = 'step'
FBX = 'fbx'
FBXB = 'fbxb'
def __str__(self) -> str:
return str(self.value)

12
kittycad/models/valid_source_file_format.py
View File

@ -1,12 +0,0 @@
from enum import Enum
class ValidSourceFileFormat(str, Enum):
STL = 'stl'
OBJ = 'obj'
DAE = 'dae'
STEP = 'step'
FBX = 'fbx'
def __str__(self) -> str:
return str(self.value)