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 # stop the build if there are Python syntax errors or undefined names
poetry run flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics 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 # 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 - name: Run pytest
shell: bash shell: bash

14
generate/generate.py
View File

@ -114,7 +114,7 @@ def generatePath(
success_type = endoint_refs[0] 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' fn_name += '_with_base64_helper'
# Iterate over the parameters. # Iterate over the parameters.
@ -1048,9 +1048,19 @@ def generateType(path: str, name: str, schema: dict):
f.write("\n") f.write("\n")
f.write("\tdef __str__(self) -> str:\n") f.write("\tdef __str__(self) -> str:\n")
f.write("\t\treturn str(self.value)\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: else:
print(" unsupported type: ", type_name) print(" unsupported type: ", type_name)
return raise Exception(" unsupported type: ", type_name)
# Close the file. # Close the file.
f.close() 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 import httpx
from ...client import Client from ...client import Client
from ...models.error_message import ErrorMessage from ...models import Error
from ...models.file_conversion import FileConversion from ...models import FileConversionWithOutput
from ...models.valid_source_file_format import ValidSourceFileFormat from ...models import FileConversionSourceFormat
from ...models.valid_output_file_format import ValidOutputFileFormat from ...models import FileConversionOutputFormat
from ...types import Response 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( def sync(
source_format: ValidSourceFileFormat, src_format: FileConversionSourceFormat,
output_format: ValidOutputFileFormat, output_format: FileConversionOutputFormat,
body: bytes, body: bytes,
*, *,
client: Client, 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.""" """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) encoded = base64.b64encode(body)
fc = fc_sync( fc = fc_sync(
source_format=source_format, src_format=src_format,
output_format=output_format, output_format=output_format,
body=encoded, body=encoded,
client=client, client=client,
) )
if isinstance(fc, FileConversion) and fc.output != "": if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output) fc.output = base64.b64decode(fc.output)
return fc return fc
async def asyncio( async def asyncio(
source_format: ValidSourceFileFormat, src_format: FileConversionSourceFormat,
output_format: ValidOutputFileFormat, output_format: FileConversionOutputFormat,
body: bytes, body: bytes,
*, *,
client: Client, 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.""" """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) encoded = base64.b64encode(body)
fc = await fc_asyncio( fc = await fc_asyncio(
source_format=source_format, src_format=src_format,
output_format=output_format, output_format=output_format,
body=encoded, body=encoded,
client=client, client=client,
) )
if isinstance(fc, FileConversion) and fc.output != "": if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output) fc.output = base64.b64decode(fc.output)
return fc 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 import httpx
from ...client import Client from ...client import Client
from ...models.error_message import ErrorMessage from ...models import Error
from ...models.file_conversion import FileConversion from ...models.file_conversion import FileConversionWithOutput
from ...types import Response 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( def sync(
id: str, id: str,
*, *,
client: Client, 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.""" """Get the status of a file conversion. This function automatically base64 decodes the output response if there is one."""
fc = fc_sync( fc = fc_sync(
@ -22,7 +22,7 @@ def sync(
client=client, client=client,
) )
if isinstance(fc, FileConversion) and fc.output != "": if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output) fc.output = base64.b64decode(fc.output)
return fc return fc
@ -32,7 +32,7 @@ async def asyncio(
id: str, id: str,
*, *,
client: Client, 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.""" """Get the status of a file conversion. This function automatically base64 decodes the output response if there is one."""
fc = await fc_asyncio( fc = await fc_asyncio(
@ -40,7 +40,7 @@ async def asyncio(
client=client, client=client,
) )
if isinstance(fc, FileConversion) and fc.output != "": if isinstance(fc, FileConversionWithOutput) and fc.output != "":
fc.output = base64.b64decode(fc.output) fc.output = base64.b64decode(fc.output)
return fc 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 import asyncio
from .client import ClientFromEnv from .client import ClientFromEnv
from .models import FileConversion, ValidOutputFileFormat, ValidSourceFileFormat, AuthSession, Instance, PongMessage, FileConversionStatus from .models import FileConversion, FileConversionOutputFormat, FileConversionSourceFormat, User, Pong, FileConversionStatus
from .api.file import post_file_conversion_with_base64_helper from .api.file import create_file_conversion_with_base64_helper
from .api.meta import auth_session, instance_metadata, ping from .api.meta import ping
from .api.users import get_user_self
def test_get_session(): def test_get_session():
@ -13,7 +14,7 @@ def test_get_session():
client = ClientFromEnv() client = ClientFromEnv()
# Get the session. # Get the session.
session: AuthSession = auth_session.sync(client=client) session: User = get_user_self.sync(client=client)
assert session is not None assert session is not None
@ -26,44 +27,19 @@ async def test_get_session_async():
client = ClientFromEnv() client = ClientFromEnv()
# Get the session. # 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 assert session is not None
print(f"Session: {session}") 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(): def test_ping():
# Create our client. # Create our client.
client = ClientFromEnv() client = ClientFromEnv()
# Get the message. # Get the message.
message: PongMessage = ping.sync(client=client) message: Pong = ping.sync(client=client)
assert message is not None assert message is not None
@ -76,7 +52,7 @@ async def test_ping_async():
client = ClientFromEnv() client = ClientFromEnv()
# Get the message. # Get the message.
message: PongMessage = await ping.asyncio(client=client) message: Pong = await ping.asyncio(client=client)
assert message is not None assert message is not None
@ -93,11 +69,11 @@ def test_file_convert_stl():
file.close() file.close()
# Get the fc. # Get the fc.
fc: FileConversion = post_file_conversion_with_base64_helper.sync( fc: FileConversion = create_file_conversion_with_base64_helper.sync(
client=client, client=client,
body=content, body=content,
source_format=ValidSourceFileFormat.STL, src_format=FileConversionSourceFormat.STL,
output_format=ValidOutputFileFormat.OBJ) output_format=FileConversionOutputFormat.OBJ)
assert fc is not None assert fc is not None
@ -121,7 +97,7 @@ async def test_file_convert_stl_async():
file.close() file.close()
# Get the fc. # 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 assert fc is not None

2
kittycad/models/api_call_query_group.py
View File

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

1
kittycad/models/api_call_query_group_by.py
View File

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

2
kittycad/models/api_call_with_price.py
View File

@ -11,7 +11,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ApiCallWithPrice") T = TypeVar("T", bound="ApiCallWithPrice")
@attr.s(auto_attribs=True) @attr.s(auto_attribs=True)
class ApiCallWithPrice: class ApiCallWithPrice:
""" """ """ """
@ -211,6 +210,7 @@ class ApiCallWithPrice:
user_id = d.pop("user_id", UNSET) user_id = d.pop("user_id", UNSET)
api_call_with_price = cls( api_call_with_price = cls(
completed_at= completed_at, completed_at= completed_at,
created_at= created_at, created_at= created_at,

2
kittycad/models/api_token.py
View File

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

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 from enum import Enum
class CreatedAtSortMode(str, Enum): class CreatedAtSortMode(str, Enum):
CREATED_AT_ASCENDING = 'created-at-ascending' CREATED_AT_ASCENDING = 'created-at-ascending'
CREATED_AT_DESCENDING = 'created-at-descending' CREATED_AT_DESCENDING = 'created-at-descending'

2
kittycad/models/error.py
View File

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

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

2
kittycad/models/extended_user.py
View File

@ -8,7 +8,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="ExtendedUser") T = TypeVar("T", bound="ExtendedUser")
@attr.s(auto_attribs=True) @attr.s(auto_attribs=True)
class ExtendedUser: class ExtendedUser:
""" """ """ """
@ -143,6 +142,7 @@ class ExtendedUser:
zendesk_id = d.pop("zendesk_id", UNSET) zendesk_id = d.pop("zendesk_id", UNSET)
extended_user = cls( extended_user = cls(
company= company, company= company,
created_at= created_at, created_at= created_at,

2
kittycad/models/file_conversion.py
View File

@ -12,7 +12,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="FileConversion") T = TypeVar("T", bound="FileConversion")
@attr.s(auto_attribs=True) @attr.s(auto_attribs=True)
class FileConversion: class FileConversion:
""" """ """ """
@ -158,6 +157,7 @@ class FileConversion:
worker = d.pop("worker", UNSET) worker = d.pop("worker", UNSET)
file_conversion = cls( file_conversion = cls(
completed_at= completed_at, completed_at= completed_at,
created_at= created_at, created_at= created_at,

1
kittycad/models/file_conversion_output_format.py
View File

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

1
kittycad/models/file_conversion_source_format.py
View File

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

1
kittycad/models/file_conversion_status.py
View File

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

2
kittycad/models/file_conversion_with_output.py
View File

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

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 from enum import Enum
class Method(str, Enum): class Method(str, Enum):
OPTIONS = 'OPTIONS' OPTIONS = 'OPTIONS'
GET = 'GET' GET = 'GET'

2
kittycad/models/pong.py
View File

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

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

2
kittycad/models/user.py
View File

@ -8,7 +8,6 @@ from ..types import UNSET, Unset
T = TypeVar("T", bound="User") T = TypeVar("T", bound="User")
@attr.s(auto_attribs=True) @attr.s(auto_attribs=True)
class User: class User:
""" """ """ """
@ -125,6 +124,7 @@ class User:
else: else:
updated_at = isoparse(_updated_at) updated_at = isoparse(_updated_at)
user = cls( user = cls(
company= company, company= company,
created_at= created_at, created_at= created_at,

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)