aadml-training 0.1.0__tar.gz

aadml_training-0.1.0/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: pip
+    directory: /
+    schedule:
+      interval: weekly

aadml_training-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: ${{ matrix.python }}
+      - run: python -m pip install ".[test]"
+      - run: python -m pytest -q

aadml_training-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,47 @@
+name: Release
+
+# A tag v<version> builds the package and publishes it to pypi.org with PyPI's trusted publishing: no PyPI token is
+# stored anywhere. The tag must match src/aadml_training/_version.py.
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+      - name: The tag matches the version
+        run: |
+          version=$(python -c "import re;print(re.search(r'\"(.+)\"', open('src/aadml_training/_version.py').read())[1])")
+          test "v$version" = "$GITHUB_REF_NAME" || { echo "tag $GITHUB_REF_NAME is not v$version"; exit 1; }
+      - run: python -m pip install ".[test]" build==1.2.2.post1
+      - run: python -m pytest -q
+      - run: python -m build
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/aadml-training/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # v1.12.4

aadml_training-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.env

aadml_training-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0
+
+- `Client`: AADML's address and your app key (`AADML_API_KEY`, `AADML_API_URL`), timeouts and retries that never send
+  a request twice when it may have been processed.
+- Photo models: `predict` (a file path, bytes, an open file, a URL or a Pillow image).
+- Chat models: `chat`, `chat_text`, `chat_stream`, `models`, in OpenAI's chat completions format.
+- One error kind per answer: `AuthenticationError`, `PermissionDeniedError`, `BadRequestError`,
+  `PayloadTooLargeError`, `RateLimitError`, `ModelUnavailableError`, `ServerError`, `ConnectionError`.

aadml_training-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

aadml_training-0.1.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: aadml-training
+Version: 0.1.0
+Summary: Python SDK for AADML Training: call your trained photo and chat models from your own code.
+Project-URL: Homepage, https://aadml.com
+Project-URL: Source, https://github.com/sajid-the-backend-engineer/aadml-training
+Project-URL: Issues, https://github.com/sajid-the-backend-engineer/aadml-training/issues
+Project-URL: Changelog, https://github.com/sajid-the-backend-engineer/aadml-training/blob/main/CHANGELOG.md
+Author: Northrays
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: aadml,computer vision,inference,llm,machine learning,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: test
+Requires-Dist: pytest==8.3.5; extra == 'test'
+Description-Content-Type: text/markdown
+
+# aadml-training
+
+The Python SDK for [AADML](https://aadml.com) Training: call the photo and chat models you trained and deployed in
+AADML from your own code.
+
+```bash
+pip install aadml-training
+```
+
+Python 3.9 or newer. One dependency: [httpx](https://www.python-httpx.org/).
+
+## Your key
+
+Make an app key on your project's **Deploy** page (Connected apps), and allow it the environment you will call
+(staging or production). Keep it secret: anyone with the key can call your model, and calls may be charged.
+
+```bash
+export AADML_API_KEY="your app key"
+```
+
+## Photo models
+
+```python
+from aadml_training import Client
+
+client = Client()                                    # reads AADML_API_KEY; or Client(api_key="...")
+
+result = client.predict(project_id=22, image="room.jpg")          # production by default
+for wall in result["walls"]:
+    print(wall["id"], wall["corners"])
+for opening in result["openings"]:
+    print(opening["type"], opening["polygon"])       # windows and doors
+```
+
+`image` can be a file path, bytes, an open binary file, a URL or a Pillow image: JPEG, PNG or WebP, at most 15 MB.
+Coordinates are in the photo's own pixels. Pass `environment="staging"` to call the staging model, and your own
+`request_id` / `capture_id` to find a call again later.
+
+## Chat models
+
+A chat model's project answers in OpenAI's chat completions format.
+
+```python
+messages = [{"role": "user", "content": "How do I return an order?"}]
+
+print(client.chat_text(project_id=31, messages=messages))
+
+for piece in client.chat_stream(project_id=31, messages=messages):     # as the model writes it
+    print(piece, end="", flush=True)
+
+answer = client.chat(project_id=31, messages=messages, max_tokens=200)  # the whole completion
+print(client.models(project_id=31))                                      # the models it answers with
+```
+
+## Errors
+
+Every error is an `aadml_training.AADMLError`. An error answer from AADML is an `APIError` with `status_code`,
+`message` and, when AADML names one, `field`:
+
+| Error | When |
+|---|---|
+| `AuthenticationError` (401) | The key is missing, unknown or revoked |
+| `PermissionDeniedError` (403) | The key has no access to that project and environment |
+| `BadRequestError` (400) | The request was refused, for example a file that is not a photo |
+| `PayloadTooLargeError` (413) | The photo is larger than 15 MB |
+| `RateLimitError` (429) | Too many requests for this key; `retry_after` says how long to wait |
+| `ModelUnavailableError` (503) | No model is deployed to that environment yet, or it is starting |
+| `ServerError` (5xx) | AADML or the model failed to answer |
+| `ConnectionError` | AADML could not be reached |
+
+```python
+from aadml_training import ModelUnavailableError
+
+try:
+    result = client.predict(project_id=22, image="room.jpg")
+except ModelUnavailableError as error:
+    print("Not ready yet:", error.message, "try again in", error.retry_after, "seconds")
+```
+
+## Retries
+
+A request AADML refused **without processing it** (429, 503) or that never reached AADML is sent again, waiting as
+AADML asks (at most 30 seconds), up to `max_retries` times (2 by default). A request that may have been processed is
+never sent twice, so you are never charged twice for one call.
+
+```python
+client = Client(timeout=30, max_retries=0)
+```
+
+## Settings
+
+| Setting | Argument | Environment variable | Default |
+|---|---|---|---|
+| API key | `api_key` | `AADML_API_KEY` | none: required |
+| AADML's address | `api_url` | `AADML_API_URL` | `https://aadml.com` |
+| Seconds to wait for an answer | `timeout` | | 60 |
+| Times a request is sent again | `max_retries` | | 2 |
+
+## About this package
+
+`aadml-training` covers AADML Training. It will become part of the general `aadml` SDK; this package will then point
+to it.
+
+Licence: Apache 2.0. Report a security problem privately (see [SECURITY.md](SECURITY.md)).

aadml_training-0.1.0/README.md

@@ -0,0 +1,104 @@
+# aadml-training
+
+The Python SDK for [AADML](https://aadml.com) Training: call the photo and chat models you trained and deployed in
+AADML from your own code.
+
+```bash
+pip install aadml-training
+```
+
+Python 3.9 or newer. One dependency: [httpx](https://www.python-httpx.org/).
+
+## Your key
+
+Make an app key on your project's **Deploy** page (Connected apps), and allow it the environment you will call
+(staging or production). Keep it secret: anyone with the key can call your model, and calls may be charged.
+
+```bash
+export AADML_API_KEY="your app key"
+```
+
+## Photo models
+
+```python
+from aadml_training import Client
+
+client = Client()                                    # reads AADML_API_KEY; or Client(api_key="...")
+
+result = client.predict(project_id=22, image="room.jpg")          # production by default
+for wall in result["walls"]:
+    print(wall["id"], wall["corners"])
+for opening in result["openings"]:
+    print(opening["type"], opening["polygon"])       # windows and doors
+```
+
+`image` can be a file path, bytes, an open binary file, a URL or a Pillow image: JPEG, PNG or WebP, at most 15 MB.
+Coordinates are in the photo's own pixels. Pass `environment="staging"` to call the staging model, and your own
+`request_id` / `capture_id` to find a call again later.
+
+## Chat models
+
+A chat model's project answers in OpenAI's chat completions format.
+
+```python
+messages = [{"role": "user", "content": "How do I return an order?"}]
+
+print(client.chat_text(project_id=31, messages=messages))
+
+for piece in client.chat_stream(project_id=31, messages=messages):     # as the model writes it
+    print(piece, end="", flush=True)
+
+answer = client.chat(project_id=31, messages=messages, max_tokens=200)  # the whole completion
+print(client.models(project_id=31))                                      # the models it answers with
+```
+
+## Errors
+
+Every error is an `aadml_training.AADMLError`. An error answer from AADML is an `APIError` with `status_code`,
+`message` and, when AADML names one, `field`:
+
+| Error | When |
+|---|---|
+| `AuthenticationError` (401) | The key is missing, unknown or revoked |
+| `PermissionDeniedError` (403) | The key has no access to that project and environment |
+| `BadRequestError` (400) | The request was refused, for example a file that is not a photo |
+| `PayloadTooLargeError` (413) | The photo is larger than 15 MB |
+| `RateLimitError` (429) | Too many requests for this key; `retry_after` says how long to wait |
+| `ModelUnavailableError` (503) | No model is deployed to that environment yet, or it is starting |
+| `ServerError` (5xx) | AADML or the model failed to answer |
+| `ConnectionError` | AADML could not be reached |
+
+```python
+from aadml_training import ModelUnavailableError
+
+try:
+    result = client.predict(project_id=22, image="room.jpg")
+except ModelUnavailableError as error:
+    print("Not ready yet:", error.message, "try again in", error.retry_after, "seconds")
+```
+
+## Retries
+
+A request AADML refused **without processing it** (429, 503) or that never reached AADML is sent again, waiting as
+AADML asks (at most 30 seconds), up to `max_retries` times (2 by default). A request that may have been processed is
+never sent twice, so you are never charged twice for one call.
+
+```python
+client = Client(timeout=30, max_retries=0)
+```
+
+## Settings
+
+| Setting | Argument | Environment variable | Default |
+|---|---|---|---|
+| API key | `api_key` | `AADML_API_KEY` | none: required |
+| AADML's address | `api_url` | `AADML_API_URL` | `https://aadml.com` |
+| Seconds to wait for an answer | `timeout` | | 60 |
+| Times a request is sent again | `max_retries` | | 2 |
+
+## About this package
+
+`aadml-training` covers AADML Training. It will become part of the general `aadml` SDK; this package will then point
+to it.
+
+Licence: Apache 2.0. Report a security problem privately (see [SECURITY.md](SECURITY.md)).

aadml_training-0.1.0/SECURITY.md

@@ -0,0 +1,8 @@
+# Security
+
+Please report a security problem privately, never in a public issue: use GitHub's **Report a vulnerability** on this
+repository's Security tab. Say what you found, how to reproduce it, and which version you used. We answer as soon as we
+can and tell you when it is fixed.
+
+Never include a real API key in a report, an issue or an example. If you published one by mistake, revoke it on your
+project's Deploy page and make a new one.

aadml_training-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling==1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aadml-training"
+dynamic = ["version"]
+description = "Python SDK for AADML Training: call your trained photo and chat models from your own code."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Northrays" }]
+keywords = ["aadml", "machine learning", "computer vision", "llm", "inference", "sdk"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.27,<1"]
+
+[project.optional-dependencies]
+test = ["pytest==8.3.5"]
+
+[project.urls]
+Homepage = "https://aadml.com"
+Source = "https://github.com/sajid-the-backend-engineer/aadml-training"
+Issues = "https://github.com/sajid-the-backend-engineer/aadml-training/issues"
+Changelog = "https://github.com/sajid-the-backend-engineer/aadml-training/blob/main/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "src/aadml_training/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aadml_training"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

aadml_training-0.1.0/src/aadml_training/__init__.py

@@ -0,0 +1,16 @@
+"""AADML Training's Python SDK: call your trained photo and chat models from your own code.
+
+    from aadml_training import Client
+
+    client = Client(api_key="...")
+    result = client.predict(project_id=22, image="room.jpg")
+"""
+from ._version import __version__
+from .client import DEFAULT_API_URL, Client
+from .errors import (AADMLError, APIError, AuthenticationError, BadRequestError, ConfigurationError, ConnectionError,
+                     ModelUnavailableError, NotFoundError, PayloadTooLargeError, PermissionDeniedError, RateLimitError,
+                     ServerError)
+
+__all__ = ["Client", "DEFAULT_API_URL", "__version__", "AADMLError", "APIError", "AuthenticationError",
+           "BadRequestError", "ConfigurationError", "ConnectionError", "ModelUnavailableError", "NotFoundError",
+           "PayloadTooLargeError", "PermissionDeniedError", "RateLimitError", "ServerError"]

aadml_training-0.1.0/src/aadml_training/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

aadml_training-0.1.0/src/aadml_training/client.py

@@ -0,0 +1,192 @@
+"""The client: one object that holds AADML's address and your API key, with one method per thing you can ask.
+
+    from aadml_training import Client
+
+    client = Client(api_key="...")                       # or set AADML_API_KEY
+    walls = client.predict(project_id=22, image="room.jpg")
+    reply = client.chat(project_id=31, messages=[{"role": "user", "content": "How do I return an order?"}])
+
+The key is an app key made on the project's Deploy page (Connected apps); it is sent as ``Authorization: Bearer``
+and never written to a log or a repr.
+"""
+import json
+import os
+import time
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Optional
+
+import httpx
+
+from . import errors
+from ._version import __version__
+from .images import ImageInput, load
+
+DEFAULT_API_URL = "https://aadml.com"
+ENVIRONMENTS = ("staging", "production")
+#: Statuses that mean the request was NOT processed, so sending it again cannot do (or charge for) the work twice.
+_RETRY_STATUSES = (429, 503)
+_MAX_WAIT = 30.0
+
+
+class Client:
+    """AADML Training's API.
+
+    ``api_key``: an app key from the project's Deploy page; ``AADML_API_KEY`` when not given.
+    ``api_url``: AADML's address; ``AADML_API_URL`` or https://aadml.com when not given.
+    ``timeout``: seconds to wait for one answer. ``max_retries``: how many times a request that AADML refused
+    without processing it (429 too many requests, 503 model not ready) or that never reached AADML is sent again,
+    waiting as AADML asks (at most 30 seconds each time)."""
+
+    def __init__(self, api_key: Optional[str] = None, api_url: Optional[str] = None, *, timeout: float = 60.0,
+                 max_retries: int = 2, http_client: Optional[httpx.Client] = None):
+        key = api_key if api_key is not None else os.environ.get("AADML_API_KEY", "")
+        if not key or not key.strip():
+            raise errors.ConfigurationError("No API key: pass api_key=... or set AADML_API_KEY.")
+        url = (api_url or os.environ.get("AADML_API_URL") or DEFAULT_API_URL).rstrip("/")
+        if not url.startswith(("https://", "http://")):
+            raise errors.ConfigurationError(f"api_url must start with https:// (got {url!r}).")
+        self.api_url = url
+        self.timeout = timeout
+        self.max_retries = max(0, int(max_retries))
+        self.__key = key.strip()
+        self._http = http_client or httpx.Client(timeout=timeout)
+        self._owns_http = http_client is None
+
+    def __repr__(self) -> str:
+        return f"Client(api_url={self.api_url!r}, api_key='{self.__key[:4]}…')"
+
+    def close(self) -> None:
+        if self._owns_http:
+            self._http.close()
+
+    def __enter__(self) -> "Client":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    # ── photo models ─────────────────────────────────────────────────────────────────────────────────────────────
+    def predict(self, project_id: int, image: ImageInput, *, environment: str = "production",
+                request_id: Optional[str] = None, capture_id: Optional[str] = None) -> Dict[str, Any]:
+        """Send one photo to the model deployed in a project's ``environment`` and return what it found: ``walls``
+        (each with its corners), ``openings`` (windows and doors), in the photo's own pixels, with ``model``,
+        ``request_id``, ``warnings`` and ``timing_ms``.
+
+        ``image``: a file path, bytes, an open binary file, a URL or a Pillow image (JPEG, PNG or WebP, at most 15 MB).
+        ``request_id`` / ``capture_id``: your own ids (at most 128 characters), returned in the answer."""
+        data, content_type, name = load(image, timeout=self.timeout)
+        payload = {key: value for key, value in (("request_id", request_id), ("capture_id", capture_id)) if value}
+        form = {"payload": json.dumps(payload)} if payload else None
+        return self._send("POST", self._project_path(project_id, environment, "predict/"),
+                          files={"file": (name, data, content_type)}, data=form).json()
+
+    # ── chat models ──────────────────────────────────────────────────────────────────────────────────────────────
+    def chat(self, project_id: int, messages: List[Dict[str, Any]], *, environment: str = "production",
+             **options: Any) -> Dict[str, Any]:
+        """Ask a project's deployed chat model, in OpenAI's chat completions format; returns the completion
+        (``answer["choices"][0]["message"]["content"]`` is the reply). ``options`` go into the request as they are
+        (``max_tokens``, ``temperature``, …)."""
+        body = {"messages": messages, **options, "stream": False}
+        return self._send("POST", self._project_path(project_id, environment, "v1/chat/completions"), json=body).json()
+
+    def chat_text(self, project_id: int, messages: List[Dict[str, Any]], **kwargs: Any) -> str:
+        """``chat``, returning only the reply's text."""
+        answer = self.chat(project_id, messages, **kwargs)
+        return (answer.get("choices") or [{}])[0].get("message", {}).get("content") or ""
+
+    def chat_stream(self, project_id: int, messages: List[Dict[str, Any]], *, environment: str = "production",
+                    **options: Any) -> Iterator[str]:
+        """``chat``, yielding the reply's text piece by piece as the model writes it."""
+        body = {"messages": messages, **options, "stream": True}
+        path = self._project_path(project_id, environment, "v1/chat/completions")
+        with self._stream("POST", path, json=body) as answer:
+            for line in answer.iter_lines():
+                if not line.startswith("data:"):
+                    continue
+                data = line[5:].strip()
+                if data == "[DONE]":
+                    return
+                try:
+                    chunk = json.loads(data)
+                except ValueError:
+                    continue
+                if chunk.get("error"):
+                    raise errors.ServerError(str(chunk["error"].get("message") or chunk["error"]), 502, body=chunk)
+                for choice in chunk.get("choices") or []:
+                    piece = (choice.get("delta") or {}).get("content")
+                    if piece:
+                        yield piece
+
+    def models(self, project_id: int, *, environment: str = "production") -> List[Dict[str, Any]]:
+        """The chat models a project's ``environment`` answers with (OpenAI's model list)."""
+        return self._send("GET", self._project_path(project_id, environment, "v1/models")).json().get("data", [])
+
+    # ── plumbing ─────────────────────────────────────────────────────────────────────────────────────────────────
+    def _project_path(self, project_id: int, environment: str, rest: str) -> str:
+        if environment not in ENVIRONMENTS:
+            raise errors.ConfigurationError(f"environment must be one of {', '.join(ENVIRONMENTS)} (got {environment!r}).")
+        if isinstance(project_id, bool) or not str(project_id).isdigit():
+            raise errors.ConfigurationError(f"project_id is the project's number (got {project_id!r}).")
+        return f"/api/training-data/v1/projects/{int(project_id)}/environments/{environment}/{rest}"
+
+    def _headers(self) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {self.__key}", "User-Agent": f"aadml-training-python/{__version__}",
+                "Accept": "application/json"}
+
+    def _send(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        attempt = 0
+        while True:
+            try:
+                answer = self._http.request(method, self.api_url + path, headers=self._headers(), timeout=self.timeout,
+                                            **kwargs)
+            except httpx.ConnectError as failure:                          # never reached AADML: safe to send again
+                if attempt < self.max_retries:
+                    attempt += 1
+                    time.sleep(min(2 ** attempt, _MAX_WAIT))
+                    continue
+                raise errors.ConnectionError(f"Could not reach {self.api_url}: {failure}") from None
+            except httpx.TimeoutException:
+                raise errors.ConnectionError(f"No answer from {self.api_url} within {self.timeout} seconds.") from None
+            if answer.status_code < 400:
+                return answer
+            failure = _error(answer)
+            if answer.status_code in _RETRY_STATUSES and attempt < self.max_retries:
+                attempt += 1
+                time.sleep(min(failure.retry_after or 2 ** attempt, _MAX_WAIT))
+                continue
+            raise failure
+
+    @contextmanager
+    def _stream(self, method: str, path: str, **kwargs: Any) -> Iterator[httpx.Response]:
+        try:
+            with self._http.stream(method, self.api_url + path, headers=self._headers(), timeout=self.timeout,
+                                   **kwargs) as answer:
+                if answer.status_code >= 400:
+                    answer.read()
+                    raise _error(answer)
+                yield answer
+        except httpx.ConnectError as failure:
+            raise errors.ConnectionError(f"Could not reach {self.api_url}: {failure}") from None
+        except httpx.TimeoutException:
+            raise errors.ConnectionError(f"No answer from {self.api_url} within {self.timeout} seconds.") from None
+
+
+def _error(answer: httpx.Response) -> errors.APIError:
+    """The APIError for an error answer: AADML's ``{"error", "field"}`` or OpenAI's ``{"error": {"message"}}``."""
+    try:
+        body = answer.json()
+    except ValueError:
+        body = {}
+    raw = body.get("error") if isinstance(body, dict) else None
+    if isinstance(raw, dict):
+        message, field = raw.get("message") or "", raw.get("param")
+    else:
+        message, field = raw or "", body.get("field") if isinstance(body, dict) else None
+    retry = answer.headers.get("Retry-After")
+    try:
+        retry_after = float(retry) if retry else None
+    except ValueError:
+        retry_after = None
+    kind = errors.error_for(answer.status_code)
+    return kind(message or f"AADML answered {answer.status_code}.", answer.status_code, field=field,
+                retry_after=retry_after, body=body if isinstance(body, dict) else {})

aadml_training-0.1.0/src/aadml_training/errors.py

@@ -0,0 +1,81 @@
+"""The errors the client raises. Every one is an ``AADMLError``; an answer from AADML that is not a success is an
+``APIError`` (or one of its kinds) with the HTTP status and AADML's own message."""
+from typing import Optional
+
+
+class AADMLError(Exception):
+    """Anything that went wrong in this SDK."""
+
+
+class ConfigurationError(AADMLError):
+    """The client cannot be used as it was set up: no API key, or an address that is not http(s)."""
+
+
+class ConnectionError(AADMLError):  # noqa: A001 - the SDK's own name, imported from this package
+    """AADML could not be reached: no answer came back."""
+
+
+class APIError(AADMLError):
+    """AADML answered with an error.
+
+    ``status_code`` is the HTTP status, ``message`` AADML's explanation, ``field`` the request field it is about
+    (when there is one) and ``retry_after`` the seconds AADML asked to wait before trying again (when it said)."""
+
+    def __init__(self, message: str, status_code: int, field: Optional[str] = None,
+                 retry_after: Optional[float] = None, body: Optional[dict] = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.field = field
+        self.retry_after = retry_after
+        self.body = body or {}
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(status_code={self.status_code}, message={self.message!r}, field={self.field!r})"
+
+    def __str__(self) -> str:
+        where = f" (field: {self.field})" if self.field else ""
+        return f"{self.status_code}: {self.message}{where}"
+
+
+class BadRequestError(APIError):
+    """400: the request itself was refused, for example a photo that is not a JPEG, PNG or WebP."""
+
+
+class AuthenticationError(APIError):
+    """401: the API key is missing, unknown or revoked."""
+
+
+class PermissionDeniedError(APIError):
+    """403: the key is valid but has no access to that project and environment."""
+
+
+class NotFoundError(APIError):
+    """404: there is no such project or environment."""
+
+
+class PayloadTooLargeError(APIError):
+    """413: the photo is larger than AADML accepts."""
+
+
+class RateLimitError(APIError):
+    """429: too many requests for this key. ``retry_after`` says how long to wait."""
+
+
+class ModelUnavailableError(APIError):
+    """503: no model is deployed to that environment yet, or it is starting. ``retry_after`` says when to try again."""
+
+
+class ServerError(APIError):
+    """5xx: AADML or the model failed to answer."""
+
+
+_BY_STATUS = {400: BadRequestError, 401: AuthenticationError, 403: PermissionDeniedError, 404: NotFoundError,
+              413: PayloadTooLargeError, 429: RateLimitError, 503: ModelUnavailableError}
+
+
+def error_for(status_code: int) -> type:
+    """The APIError kind of an HTTP status."""
+    if status_code in _BY_STATUS:
+        return _BY_STATUS[status_code]
+    return ServerError if status_code >= 500 else APIError

aadml_training-0.1.0/src/aadml_training/images.py

@@ -0,0 +1,73 @@
+"""Turning what a caller gives as a photo into bytes: a file path, bytes, an open binary file, a URL, or a Pillow
+image. Nothing here is sent anywhere; ``Client.predict`` sends the bytes to AADML."""
+import io
+import os
+from pathlib import Path
+from typing import Any, Tuple, Union
+
+import httpx
+
+from .errors import BadRequestError, PayloadTooLargeError
+
+#: The largest photo AADML accepts (its prediction API refuses anything larger).
+MAX_BYTES = 15 * 1024 * 1024
+_TYPES = {b"\xff\xd8\xff": ("image/jpeg", ".jpg"), b"\x89PNG": ("image/png", ".png")}
+
+ImageInput = Union[str, os.PathLike, bytes, bytearray, Any]
+
+
+def _kind(data: bytes) -> Tuple[str, str]:
+    for magic, kind in _TYPES.items():
+        if data.startswith(magic):
+            return kind
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "image/webp", ".webp"
+    raise BadRequestError("The photo must be a JPEG, PNG or WebP image.", 400, field="image")
+
+
+def _checked(data: bytes) -> Tuple[bytes, str, str]:
+    if not data:
+        raise BadRequestError("The photo is empty.", 400, field="image")
+    if len(data) > MAX_BYTES:
+        raise PayloadTooLargeError(f"The photo is larger than {MAX_BYTES // (1024 * 1024)} MB.", 413, field="image")
+    content_type, suffix = _kind(data)
+    return data, content_type, suffix
+
+
+def _download(url: str, timeout: float) -> bytes:
+    with httpx.stream("GET", url, timeout=timeout, follow_redirects=True) as answer:
+        answer.raise_for_status()
+        chunks, size = [], 0
+        for chunk in answer.iter_bytes():
+            size += len(chunk)
+            if size > MAX_BYTES:
+                raise PayloadTooLargeError(f"The photo at {url} is larger than {MAX_BYTES // (1024 * 1024)} MB.", 413,
+                                      field="image")
+            chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def load(image: ImageInput, timeout: float = 30.0) -> Tuple[bytes, str, str]:
+    """``(bytes, content type, file name)`` of the photo ``image``."""
+    if isinstance(image, (bytes, bytearray)):
+        data, content_type, suffix = _checked(bytes(image))
+        return data, content_type, "image" + suffix
+    if isinstance(image, str) and image.startswith(("http://", "https://")):
+        data, content_type, suffix = _checked(_download(image, timeout))
+        return data, content_type, "image" + suffix
+    if isinstance(image, (str, os.PathLike)):
+        path = Path(image)
+        if not path.is_file():
+            raise BadRequestError(f"There is no file at {path}.", 400, field="image")
+        data, content_type, _suffix = _checked(path.read_bytes())
+        return data, content_type, path.name
+    if hasattr(image, "read"):
+        data, content_type, suffix = _checked(image.read())
+        return data, content_type, Path(getattr(image, "name", "image" + suffix)).name
+    if hasattr(image, "save") and hasattr(image, "mode"):             # a Pillow image
+        out = io.BytesIO()
+        image.convert("RGB").save(out, format="JPEG", quality=95)
+        data, content_type, _suffix = _checked(out.getvalue())
+        return data, content_type, "image.jpg"
+    raise BadRequestError("Give the photo as a file path, bytes, an open binary file, a URL or a Pillow image.", 400,
+                          field="image")

aadml_training-0.1.0/tests/test_client.py

@@ -0,0 +1,191 @@
+"""The client against a stand-in AADML (httpx.MockTransport): nothing goes over the network."""
+import io
+import json
+
+import httpx
+import pytest
+
+import aadml_training
+from aadml_training import Client, errors
+from aadml_training import client as client_module
+
+JPEG = b"\xff\xd8\xff\xe0" + b"\x00" * 64
+PNG = b"\x89PNG\r\n\x1a\n" + b"\x00" * 64
+KEY = "tmd_app_secretkey123"
+ANSWER = {"status": "ok", "walls": [{"id": 1, "corners": [[1, 1], [9, 1], [9, 9], [1, 9]]}], "openings": [],
+          "request_id": "req_1", "capture_id": None, "model": {"name": "m", "version": 1}, "warnings": [],
+          "timing_ms": {"model": 5, "total": 9}}
+
+
+def make(handler, **kwargs):
+    return Client(api_key=KEY, api_url="https://aadml.test", http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+                  **kwargs)
+
+
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch):
+    slept = []
+    monkeypatch.setattr(client_module.time, "sleep", slept.append)
+    return slept
+
+
+def test_predict_sends_the_photo_with_the_key_to_the_project_environment():
+    seen = {}
+
+    def handler(request):
+        seen.update(url=str(request.url), auth=request.headers["Authorization"], agent=request.headers["User-Agent"],
+                    body=request.read())
+        return httpx.Response(200, json=ANSWER)
+
+    result = make(handler).predict(22, JPEG, environment="staging", request_id="r-7")
+    assert result["walls"][0]["corners"][0] == [1, 1]
+    assert seen["url"] == "https://aadml.test/api/training-data/v1/projects/22/environments/staging/predict/"
+    assert seen["auth"] == f"Bearer {KEY}"
+    assert seen["agent"] == f"aadml-training-python/{aadml_training.__version__}"
+    assert JPEG in seen["body"] and b'name="file"' in seen["body"]
+    assert b'{"request_id": "r-7"}' in seen["body"]
+
+
+def test_a_photo_can_be_a_path_an_open_file_or_bytes(tmp_path):
+    names = []
+
+    def handler(request):
+        names.append(request.read().split(b'filename="')[1].split(b'"')[0])
+        return httpx.Response(200, json=ANSWER)
+
+    client = make(handler)
+    path = tmp_path / "room.png"
+    path.write_bytes(PNG)
+    client.predict(1, str(path))
+    client.predict(1, path)
+    client.predict(1, io.BytesIO(JPEG))
+    client.predict(1, bytearray(JPEG))
+    assert names == [b"room.png", b"room.png", b"image.jpg", b"image.jpg"]
+
+
+def test_a_photo_that_is_not_an_image_is_refused_before_anything_is_sent():
+    def handler(request):
+        raise AssertionError("nothing should be sent")
+
+    client = make(handler)
+    with pytest.raises(errors.BadRequestError) as refused:
+        client.predict(1, b"%PDF-1.4 not a photo")
+    assert refused.value.field == "image"
+    with pytest.raises(errors.BadRequestError):
+        client.predict(1, b"")
+    with pytest.raises(errors.BadRequestError):
+        client.predict(1, "no/such/file.jpg")
+
+
+def test_errors_carry_aadmls_message_and_field():
+    def handler(request):
+        return httpx.Response(400, json={"error": "payload is not valid JSON.", "field": "payload"})
+
+    with pytest.raises(errors.BadRequestError) as refused:
+        make(handler).predict(1, JPEG)
+    assert (refused.value.status_code, refused.value.message, refused.value.field) == (400, "payload is not valid JSON.",
+                                                                                         "payload")
+
+
+@pytest.mark.parametrize("status, kind", [(401, errors.AuthenticationError), (403, errors.PermissionDeniedError),
+                                          (404, errors.NotFoundError), (413, errors.PayloadTooLargeError),
+                                          (502, errors.ServerError), (418, errors.APIError)])
+def test_each_status_has_its_error(status, kind):
+    with pytest.raises(kind):
+        make(lambda request: httpx.Response(status, json={"error": "no"})).predict(1, JPEG)
+
+
+def test_a_request_aadml_did_not_process_is_sent_again_as_it_asks(no_sleep):
+    answers = iter([httpx.Response(429, json={"error": "Too many requests."}, headers={"Retry-After": "3"}),
+                    httpx.Response(503, json={"error": "starting"}, headers={"Retry-After": "120"}),
+                    httpx.Response(200, json=ANSWER)])
+    assert make(lambda request: next(answers)).predict(1, JPEG)["status"] == "ok"
+    assert no_sleep == [3.0, 30.0]                                   # AADML's wait, never more than 30 seconds
+
+
+def test_a_request_that_may_have_been_processed_is_never_sent_twice():
+    calls = []
+
+    def handler(request):
+        calls.append(1)
+        return httpx.Response(502, json={"error": "The model did not answer."})
+
+    with pytest.raises(errors.ServerError):
+        make(handler).predict(1, JPEG)
+    assert len(calls) == 1                                          # it may have been charged: not sent again
+
+
+def test_retries_end_with_the_error():
+    calls = []
+
+    def handler(request):
+        calls.append(1)
+        return httpx.Response(503, json={"error": "No model is deployed to production for this project yet."},
+                              headers={"Retry-After": "5"})
+
+    with pytest.raises(errors.ModelUnavailableError) as refused:
+        make(handler, max_retries=1).predict(1, JPEG)
+    assert (len(calls), refused.value.retry_after) == (2, 5.0)
+
+
+def test_unreachable_aadml_is_a_connection_error():
+    def handler(request):
+        raise httpx.ConnectError("refused")
+
+    with pytest.raises(errors.ConnectionError):
+        make(handler, max_retries=1).predict(1, JPEG)
+
+
+def test_chat_uses_the_openai_format_and_chat_text_returns_the_reply():
+    seen = {}
+
+    def handler(request):
+        seen.update(url=str(request.url), body=json.loads(request.read()))
+        return httpx.Response(200, json={"choices": [{"message": {"role": "assistant", "content": "Use the Returns page."}}]})
+
+    client = make(handler)
+    messages = [{"role": "user", "content": "How do I return an order?"}]
+    assert client.chat_text(31, messages, max_tokens=50) == "Use the Returns page."
+    assert seen["url"] == "https://aadml.test/api/training-data/v1/projects/31/environments/production/v1/chat/completions"
+    assert seen["body"] == {"messages": messages, "max_tokens": 50, "stream": False}
+
+
+def test_chat_stream_yields_the_reply_as_it_is_written():
+    events = ('data: {"choices":[{"delta":{"role":"assistant"}}]}\n\n'
+              'data: {"choices":[{"delta":{"content":"Use the "}}]}\n\n'
+              ': keep-alive\n\n'
+              'data: {"choices":[{"delta":{"content":"Returns page."}}]}\n\n'
+              'data: [DONE]\n\n')
+    client = make(lambda request: httpx.Response(200, text=events, headers={"Content-Type": "text/event-stream"}))
+    assert "".join(client.chat_stream(31, [{"role": "user", "content": "?"}])) == "Use the Returns page."
+
+
+def test_chat_stream_error_answer_raises():
+    client = make(lambda request: httpx.Response(401, json={"error": {"message": "Unknown key", "type": "auth"}}))
+    with pytest.raises(errors.AuthenticationError) as refused:
+        list(client.chat_stream(31, [{"role": "user", "content": "?"}]))
+    assert refused.value.message == "Unknown key"
+
+
+def test_models_lists_the_environments_chat_models():
+    client = make(lambda request: httpx.Response(200, json={"object": "list", "data": [{"id": "chat-v2"}]}))
+    assert client.models(31) == [{"id": "chat-v2"}]
+
+
+def test_the_key_comes_from_the_environment_and_is_never_shown(monkeypatch):
+    monkeypatch.setenv("AADML_API_KEY", KEY)
+    client = Client()
+    assert KEY not in repr(client) and client.api_url == "https://aadml.com"
+    monkeypatch.delenv("AADML_API_KEY")
+    with pytest.raises(errors.ConfigurationError):
+        Client()
+
+
+def test_bad_settings_are_refused():
+    with pytest.raises(errors.ConfigurationError):
+        Client(api_key=KEY, api_url="ftp://aadml.com")
+    client = make(lambda request: httpx.Response(200, json=ANSWER))
+    with pytest.raises(errors.ConfigurationError):
+        client.predict(1, JPEG, environment="prod")
+    with pytest.raises(errors.ConfigurationError):
+        client.predict("../2", JPEG)