makeleaps-client 0.1.0__tar.gz

makeleaps_client-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.nf/tmp/
+.nf/logs/
+.nf/research/
+dist/
+__pycache__/
+.venv/
+.pytest_cache/
+.ruff_cache/
+src/makeleaps_client/_version.py

makeleaps_client-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

makeleaps_client-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 minamik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

makeleaps_client-0.1.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: makeleaps-client
+Version: 0.1.0
+Summary: Unofficial Python client library and CLI for the MakeLeaps REST API (not affiliated with MakeLeaps, Inc.)
+Project-URL: Repository, https://github.com/minamikik/makeleaps-client
+Author-email: minamik <10973755+minamikik@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: pyyaml>=6.0.3
+Description-Content-Type: text/markdown
+
+# makeleaps-client
+
+Unofficial Python client library and CLI for the MakeLeaps REST API. This project is not affiliated with or endorsed by MakeLeaps, Inc.
+
+The client targets API keys using **MakeLeaps API version `v2023.06.26`**. Response shapes and behavior were checked against that version. MakeLeaps assigns the API version to your API key; the client does not select a version in requests. Other API key versions have not been verified.
+
+Requires Python 3.12 or newer. Distributed under the MIT license.
+
+```sh
+pip install makeleaps-client
+```
+
+The package provides the `makeleaps_client` library and the `makeleaps` command. Both support read operations only: your company, documents of every type, current document PDFs, Document Archives, and PDFs preserved at the time of sending. Choose the PDF source appropriate for your records; an archive may not exist for every sent document.
+
+## Async Python library
+
+Pass credentials explicitly. The library reads neither environment variables nor configuration files. It discovers the one company associated with the API key, so no company argument is needed.
+
+```python
+import asyncio
+from pathlib import Path
+
+from makeleaps_client import MakeLeapsClient, MakeLeapsError
+
+
+async def read_documents(client_id: str, client_secret: str):
+    async with MakeLeapsClient(client_id, client_secret) as api:
+        company = await api.get_partner()
+        print(company.name)
+
+        async for document in api.list_documents(
+            document_type="invoice",
+            date_from="2025-01-01",
+            date_to="2025-12-31",
+            filters={"sent": "true"},
+        ):
+            print(document.mid, document.total, document.client.display_name)
+
+        document = await api.get_document("example-document-mid")
+        print(document.model_dump())
+        Path("current.pdf").write_bytes(
+            await api.get_document_pdf("example-document-mid")
+        )
+
+        async for archive in api.list_archives():
+            print(archive.mid, archive.date_sent)
+        Path("sent.pdf").write_bytes(
+            await api.get_archive_pdf("example-archive-mid")
+        )
+
+
+# Supply credentials from your application's own credential handling.
+# asyncio.run(read_documents(client_id, client_secret))
+```
+
+Use one client within one event loop. The async context manager closes its HTTP connections; alternatively call `await api.aclose()`. Handle request failures with `MakeLeapsError`.
+
+| Operation | Result |
+| --- | --- |
+| `await api.get_partner()` | `Partner` |
+| `api.list_documents(document_type=None, date_from=None, date_to=None, filters=None)` | Async iterator of `Document` |
+| `await api.get_document(mid)` | `Document` |
+| `await api.get_document_pdf(mid)` | PDF `bytes` |
+| `api.list_archives()` | Async iterator of `DocumentArchive` |
+| `await api.get_archive_pdf(mid)` | PDF `bytes` |
+
+Date bounds are inclusive (`date__gte` and `date__lte`). They accept `datetime.date` or ISO date strings. Other filters pass through using the API's parameter names and values. To repeat a parameter, supply pairs, for example `filters=[("document_number", "EXAMPLE-A"), ("document_number", "EXAMPLE-B")]`. MakeLeaps may silently ignore unsupported filters; consult its API documentation.
+
+List operations yield every matching record in API order. Pages contain up to 100 records, and up to eight subsequent pages are fetched together when iteration advances beyond the current batch. Stopping iteration avoids subsequent batches; pages already requested in the current batch may have completed. Use `await iterator.aclose()` when explicitly holding an iterator and ending it early.
+
+Documents include full client and client contact resources. Each document operation loads the client and contact lists once and joins them by URL. Those lists are not cached across operations. An unavailable referenced resource causes `MakeLeapsError` rather than returning a partially expanded document.
+
+Models are permissive pydantic models: all fields are optional, unknown fields are retained, and enum-like values remain strings. Known monetary and numeric fields become `Decimal`, dates become `datetime.date`, and timestamps become `datetime.datetime`. Nested line items and tax totals are also typed. `model_dump()` defaults to JSON-compatible API values, retaining unknown fields and omitting fields absent from the response. Explicit `mode="python"` produces Python values instead.
+
+The default response language is Japanese. Set `MakeLeapsClient(client_id, client_secret, language="en")` to change `Accept-Language` on all requests.
+
+## Command line
+
+The CLI reads `MAKELEAPS_CLIENT_ID` and `MAKELEAPS_CLIENT_SECRET` from its environment and passes them to the library. Set them using your shell's or process runner's credential handling. It does not read configuration files.
+
+```sh
+makeleaps --help
+makeleaps partner
+makeleaps documents list --type invoice --date-from 2025-01-01 --date-to 2025-12-31
+makeleaps documents list --filter sent=true --filter document_number=EXAMPLE-A --limit 10
+makeleaps documents get example-document-mid
+makeleaps documents pdf example-document-mid --output current.pdf
+makeleaps archives list --limit 10
+makeleaps archives pdf example-archive-mid --output sent.pdf
+makeleaps documents list --language en
+```
+
+Company, document, and archive results are written as complete YAML values to stdout. Each list is a single YAML sequence, including when empty. Monetary values remain strings in YAML. PDF commands write the original bytes to files. Failures produce an explanatory message on stderr and a nonzero exit status; completed files from an interrupted or failed bulk export remain on disk.
+
+Bulk PDF downloads create the destination directory if needed:
+
+```sh
+makeleaps documents pdf --dir ./current-pdfs --type invoice --date-from 2025-01-01 --filter sent=true
+makeleaps archives pdf --dir ./sent-pdfs --limit 100
+```
+
+Documents accept the same filters for `list` and bulk `pdf`. Archives support `--limit` and `--language`. Without `--limit`, list and bulk PDF commands process every matching record; `--limit 0` processes none. `--language` is accepted on every command, and defaults to `ja`.
+
+Bulk filenames use `<date>_<document_type>_<document_number>_<mid>.pdf`. Characters that cannot be used in portable filenames are replaced with `_`. A file with the same `mid` suffix already in the destination directory is skipped without fetching that PDF, even if its document number changed. The current document PDF and its archive PDF can differ; use separate directories for each source.
+
+## Authentication and requests
+
+Requests use HTTPS exclusively on `api.makeleaps.com`, with redirects disabled. Access tokens remain in process memory. Expired tokens and a 401 response cause reauthentication; a second 401 fails. Error messages do not include credentials, tokens, or raw response bodies.
+
+All requests on one client share a rolling limiter of 250 requests per 60 seconds and 20,000 per day, based on observed API response headers. Concurrent clients or other applications using the same credentials can consume the same server quota. A 429 response delays subsequent requests according to `Retry-After` (seconds or an HTTP date). Transport errors and server errors use exponential backoff. A request has at most four attempts, and reauthentication after a 401 is attempted once. The HTTP timeout is 60 seconds.
+
+No third-party MakeLeaps client is used. Tests replace the HTTP boundary with synthetic responses and never contact MakeLeaps:
+
+```sh
+uv run --python 3.12 pytest
+uv run --python 3.13 pytest
+uv build
+```

makeleaps_client-0.1.0/README.md

@@ -0,0 +1,118 @@
+# makeleaps-client
+
+Unofficial Python client library and CLI for the MakeLeaps REST API. This project is not affiliated with or endorsed by MakeLeaps, Inc.
+
+The client targets API keys using **MakeLeaps API version `v2023.06.26`**. Response shapes and behavior were checked against that version. MakeLeaps assigns the API version to your API key; the client does not select a version in requests. Other API key versions have not been verified.
+
+Requires Python 3.12 or newer. Distributed under the MIT license.
+
+```sh
+pip install makeleaps-client
+```
+
+The package provides the `makeleaps_client` library and the `makeleaps` command. Both support read operations only: your company, documents of every type, current document PDFs, Document Archives, and PDFs preserved at the time of sending. Choose the PDF source appropriate for your records; an archive may not exist for every sent document.
+
+## Async Python library
+
+Pass credentials explicitly. The library reads neither environment variables nor configuration files. It discovers the one company associated with the API key, so no company argument is needed.
+
+```python
+import asyncio
+from pathlib import Path
+
+from makeleaps_client import MakeLeapsClient, MakeLeapsError
+
+
+async def read_documents(client_id: str, client_secret: str):
+    async with MakeLeapsClient(client_id, client_secret) as api:
+        company = await api.get_partner()
+        print(company.name)
+
+        async for document in api.list_documents(
+            document_type="invoice",
+            date_from="2025-01-01",
+            date_to="2025-12-31",
+            filters={"sent": "true"},
+        ):
+            print(document.mid, document.total, document.client.display_name)
+
+        document = await api.get_document("example-document-mid")
+        print(document.model_dump())
+        Path("current.pdf").write_bytes(
+            await api.get_document_pdf("example-document-mid")
+        )
+
+        async for archive in api.list_archives():
+            print(archive.mid, archive.date_sent)
+        Path("sent.pdf").write_bytes(
+            await api.get_archive_pdf("example-archive-mid")
+        )
+
+
+# Supply credentials from your application's own credential handling.
+# asyncio.run(read_documents(client_id, client_secret))
+```
+
+Use one client within one event loop. The async context manager closes its HTTP connections; alternatively call `await api.aclose()`. Handle request failures with `MakeLeapsError`.
+
+| Operation | Result |
+| --- | --- |
+| `await api.get_partner()` | `Partner` |
+| `api.list_documents(document_type=None, date_from=None, date_to=None, filters=None)` | Async iterator of `Document` |
+| `await api.get_document(mid)` | `Document` |
+| `await api.get_document_pdf(mid)` | PDF `bytes` |
+| `api.list_archives()` | Async iterator of `DocumentArchive` |
+| `await api.get_archive_pdf(mid)` | PDF `bytes` |
+
+Date bounds are inclusive (`date__gte` and `date__lte`). They accept `datetime.date` or ISO date strings. Other filters pass through using the API's parameter names and values. To repeat a parameter, supply pairs, for example `filters=[("document_number", "EXAMPLE-A"), ("document_number", "EXAMPLE-B")]`. MakeLeaps may silently ignore unsupported filters; consult its API documentation.
+
+List operations yield every matching record in API order. Pages contain up to 100 records, and up to eight subsequent pages are fetched together when iteration advances beyond the current batch. Stopping iteration avoids subsequent batches; pages already requested in the current batch may have completed. Use `await iterator.aclose()` when explicitly holding an iterator and ending it early.
+
+Documents include full client and client contact resources. Each document operation loads the client and contact lists once and joins them by URL. Those lists are not cached across operations. An unavailable referenced resource causes `MakeLeapsError` rather than returning a partially expanded document.
+
+Models are permissive pydantic models: all fields are optional, unknown fields are retained, and enum-like values remain strings. Known monetary and numeric fields become `Decimal`, dates become `datetime.date`, and timestamps become `datetime.datetime`. Nested line items and tax totals are also typed. `model_dump()` defaults to JSON-compatible API values, retaining unknown fields and omitting fields absent from the response. Explicit `mode="python"` produces Python values instead.
+
+The default response language is Japanese. Set `MakeLeapsClient(client_id, client_secret, language="en")` to change `Accept-Language` on all requests.
+
+## Command line
+
+The CLI reads `MAKELEAPS_CLIENT_ID` and `MAKELEAPS_CLIENT_SECRET` from its environment and passes them to the library. Set them using your shell's or process runner's credential handling. It does not read configuration files.
+
+```sh
+makeleaps --help
+makeleaps partner
+makeleaps documents list --type invoice --date-from 2025-01-01 --date-to 2025-12-31
+makeleaps documents list --filter sent=true --filter document_number=EXAMPLE-A --limit 10
+makeleaps documents get example-document-mid
+makeleaps documents pdf example-document-mid --output current.pdf
+makeleaps archives list --limit 10
+makeleaps archives pdf example-archive-mid --output sent.pdf
+makeleaps documents list --language en
+```
+
+Company, document, and archive results are written as complete YAML values to stdout. Each list is a single YAML sequence, including when empty. Monetary values remain strings in YAML. PDF commands write the original bytes to files. Failures produce an explanatory message on stderr and a nonzero exit status; completed files from an interrupted or failed bulk export remain on disk.
+
+Bulk PDF downloads create the destination directory if needed:
+
+```sh
+makeleaps documents pdf --dir ./current-pdfs --type invoice --date-from 2025-01-01 --filter sent=true
+makeleaps archives pdf --dir ./sent-pdfs --limit 100
+```
+
+Documents accept the same filters for `list` and bulk `pdf`. Archives support `--limit` and `--language`. Without `--limit`, list and bulk PDF commands process every matching record; `--limit 0` processes none. `--language` is accepted on every command, and defaults to `ja`.
+
+Bulk filenames use `<date>_<document_type>_<document_number>_<mid>.pdf`. Characters that cannot be used in portable filenames are replaced with `_`. A file with the same `mid` suffix already in the destination directory is skipped without fetching that PDF, even if its document number changed. The current document PDF and its archive PDF can differ; use separate directories for each source.
+
+## Authentication and requests
+
+Requests use HTTPS exclusively on `api.makeleaps.com`, with redirects disabled. Access tokens remain in process memory. Expired tokens and a 401 response cause reauthentication; a second 401 fails. Error messages do not include credentials, tokens, or raw response bodies.
+
+All requests on one client share a rolling limiter of 250 requests per 60 seconds and 20,000 per day, based on observed API response headers. Concurrent clients or other applications using the same credentials can consume the same server quota. A 429 response delays subsequent requests according to `Retry-After` (seconds or an HTTP date). Transport errors and server errors use exponential backoff. A request has at most four attempts, and reauthentication after a 401 is attempted once. The HTTP timeout is 60 seconds.
+
+No third-party MakeLeaps client is used. Tests replace the HTTP boundary with synthetic responses and never contact MakeLeaps:
+
+```sh
+uv run --python 3.12 pytest
+uv run --python 3.13 pytest
+uv build
+```

makeleaps_client-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "makeleaps-client"
+dynamic = ["version"]
+description = "Unofficial Python client library and CLI for the MakeLeaps REST API (not affiliated with MakeLeaps, Inc.)"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "minamik", email = "10973755+minamikik@users.noreply.github.com" }]
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.28.1",
+    "pydantic>=2.14.1",
+    "pyyaml>=6.0.3",
+]
+
+[project.urls]
+Repository = "https://github.com/minamikik/makeleaps-client"
+
+[project.scripts]
+makeleaps = "makeleaps_client.cli:main"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+tag_regex = "^v(?P<version>[^/]+)$"
+git_describe_command = ["git", "describe", "--dirty", "--tags", "--long", "--match", "v*"]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/makeleaps_client/_version.py"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["/.nf/", "/.github/", "/noren.yaml", "/noren-words.txt"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/makeleaps_client"]
+
+[tool.pytest.ini_options]
+addopts = ["--strict-markers"]
+markers = [
+    "req(id): the adopted spec item ID that the test verifies",
+]
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

makeleaps_client-0.1.0/src/makeleaps_client/__init__.py

@@ -0,0 +1,8 @@
+"""Unofficial, async Python client for the MakeLeaps REST API."""
+from .client import MakeLeapsClient, MakeLeapsError
+from .models import Client, Contact, Document, DocumentArchive, LineItem, Partner
+
+__all__ = [
+    'MakeLeapsClient', 'MakeLeapsError', 'Partner', 'Document',
+    'DocumentArchive', 'Client', 'Contact', 'LineItem',
+]

makeleaps_client-0.1.0/src/makeleaps_client/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

makeleaps_client-0.1.0/src/makeleaps_client/cli.py

@@ -0,0 +1,171 @@
+"""Command-line interface built on the async library."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+from datetime import date
+import os
+from pathlib import Path
+import re
+import sys
+from typing import Any
+
+import yaml
+
+from .client import MakeLeapsClient, MakeLeapsError
+
+
+def _nonnegative(value: str) -> int:
+    try:
+        number = int(value)
+        if number < 0:
+            raise ValueError
+        return number
+    except ValueError:
+        raise argparse.ArgumentTypeError('limit must be a nonnegative integer') from None
+
+
+def _date(value: str) -> str:
+    try:
+        return date.fromisoformat(value).isoformat()
+    except ValueError:
+        raise argparse.ArgumentTypeError('dates must use YYYY-MM-DD') from None
+
+
+def _filter(value: str) -> tuple[str, str]:
+    key, separator, val = value.partition('=')
+    if not separator or not key:
+        raise argparse.ArgumentTypeError('filters must use key=value')
+    return key, val
+
+
+def _list_options(parser, *, documents=False):
+    parser.add_argument('--limit', type=_nonnegative, help='Maximum number of records (default: all)')
+    if documents:
+        parser.add_argument('--type', dest='document_type', help='API document_type value')
+        parser.add_argument('--date-from', type=_date, help='Inclusive issue date, YYYY-MM-DD')
+        parser.add_argument('--date-to', type=_date, help='Inclusive issue date, YYYY-MM-DD')
+        parser.add_argument('--filter', action='append', type=_filter, default=[], metavar='KEY=VALUE', help='Pass an API query parameter; may be repeated')
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog='makeleaps', description='Read MakeLeaps company data, documents, archives, and PDFs.')
+    parser.add_argument('--language', default='ja', help='Response language (default: ja)')
+    commands = parser.add_subparsers(dest='resource', required=True)
+    partner = commands.add_parser('partner', help='Get the company associated with the API key')
+    partner.add_argument('--language', default=argparse.SUPPRESS)
+    for name in ('documents', 'archives'):
+        group = commands.add_parser(name, help='Read documents' if name == 'documents' else 'Read records saved at the time of sending')
+        group.add_argument('--language', default=argparse.SUPPRESS)
+        actions = group.add_subparsers(dest='operation', required=True)
+        listing = actions.add_parser('list', help='List all matching records')
+        listing.add_argument('--language', default=argparse.SUPPRESS)
+        _list_options(listing, documents=name == 'documents')
+        if name == 'documents':
+            get = actions.add_parser('get', help='Get a document with its client and contact')
+            get.add_argument('mid')
+            get.add_argument('--language', default=argparse.SUPPRESS)
+        pdf = actions.add_parser('pdf', help='Save one PDF, or all matching PDFs with --dir')
+        pdf.add_argument('mid', nargs='?')
+        pdf.add_argument('--language', default=argparse.SUPPRESS)
+        destinations = pdf.add_mutually_exclusive_group(required=True)
+        destinations.add_argument('--output', type=Path, metavar='FILE')
+        destinations.add_argument('--dir', type=Path, metavar='DIRECTORY')
+        _list_options(pdf, documents=name == 'documents')
+    return parser
+
+
+def _safe_component(value: Any) -> str:
+    # Include Windows filename restrictions so exported names remain portable.
+    return re.sub(r'[<>:"/\\|?*\x00-\x1f\x7f]', '_', str(value)).rstrip(' .')
+
+
+def _filename(record) -> str:
+    if not record.mid:
+        raise MakeLeapsError('A PDF record is missing its mid.')
+    values = (record.date or 'unknown', record.document_type or 'unknown',
+              record.document_number or '', record.mid)
+    return '_'.join(_safe_component(value) for value in values) + '.pdf'
+
+
+async def _records(api, args):
+    if args.resource == 'documents':
+        iterator = api.list_documents(document_type=args.document_type,
+                                      date_from=args.date_from, date_to=args.date_to,
+                                      filters=args.filter)
+    else:
+        iterator = api.list_archives()
+    count = 0
+    try:
+        if args.limit == 0:
+            return
+        async for record in iterator:
+            yield record
+            count += 1
+            if args.limit is not None and count >= args.limit:
+                return
+    finally:
+        await iterator.aclose()
+
+
+async def _execute(args, client_id, client_secret):
+    async with MakeLeapsClient(client_id, client_secret, language=args.language) as api:
+        if args.resource == 'partner':
+            return (await api.get_partner()).model_dump()
+        if args.operation == 'get':
+            return (await api.get_document(args.mid)).model_dump()
+        if args.operation == 'list':
+            return [record.model_dump() async for record in _records(api, args)]
+        fetch = api.get_document_pdf if args.resource == 'documents' else api.get_archive_pdf
+        if args.mid:
+            args.output.write_bytes(await fetch(args.mid))
+            return None
+        directory = args.dir
+        directory.mkdir(parents=True, exist_ok=True)
+        existing = {path.name for path in directory.iterdir() if path.is_file()}
+        records = _records(api, args)
+        try:
+            async for record in records:
+                filename = _filename(record)
+                suffix = '_' + _safe_component(record.mid) + '.pdf'
+                if any(name.endswith(suffix) for name in existing):
+                    continue
+                (directory / filename).write_bytes(await fetch(record.mid))
+                existing.add(filename)
+        finally:
+            await records.aclose()
+        return None
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    if getattr(args, 'operation', None) == 'pdf':
+        if args.mid and args.dir:
+            parser.error('use either MID with --output, or --dir without MID')
+        if not args.mid and args.output:
+            parser.error('--output requires MID')
+        if args.mid and (args.limit is not None or (args.resource == 'documents' and any((args.document_type, args.date_from, args.date_to, args.filter)))):
+            parser.error('filters and --limit apply only to --dir')
+    if args.resource == 'documents' and getattr(args, 'date_from', None) and getattr(args, 'date_to', None):
+        if args.date_from > args.date_to:
+            parser.error('--date-from must not be later than --date-to')
+    client_id = os.environ.get('MAKELEAPS_CLIENT_ID')
+    client_secret = os.environ.get('MAKELEAPS_CLIENT_SECRET')
+    if not client_id or not client_secret:
+        print('Set both MAKELEAPS_CLIENT_ID and MAKELEAPS_CLIENT_SECRET.', file=sys.stderr)
+        return 1
+    try:
+        result = asyncio.run(_execute(args, client_id, client_secret))
+        if result is not None:
+            print(yaml.safe_dump(result, allow_unicode=True, sort_keys=False), end='')
+        return 0
+    except MakeLeapsError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    except OSError:
+        print('Unable to read or write the requested output file.', file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print('Interrupted.', file=sys.stderr)
+        return 130