oicana 0.1.0__tar.gz

oicana-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+target/
+.idea/
+output/
+.env
+.dependencies/
+e2e-tests/template/oicana-e2e-test-*.zip
+ort/
+AGENTS.md
+__pycache__/
+release.sh

oicana-0.1.0/LICENSE.md

@@ -0,0 +1,131 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization.  **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

oicana-0.1.0/PKG-INFO

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: oicana
+Version: 0.1.0
+Summary: PDF templating with Typst
+Project-URL: Homepage, https://oicana.com
+Project-URL: Repository, https://github.com/oicana/oicana
+Project-URL: Documentation, https://oicana.com/docs
+Author-email: Oicana <hello@oicana.com>
+License: # PolyForm Noncommercial License 1.0.0
+        
+        <https://polyformproject.org/licenses/noncommercial/1.0.0>
+        
+        ## Acceptance
+        
+        In order to get any license under these terms, you must agree
+        to them as both strict obligations and conditions to all
+        your licenses.
+        
+        ## Copyright License
+        
+        The licensor grants you a copyright license for the
+        software to do everything you might do with the software
+        that would otherwise infringe the licensor's copyright
+        in it for any permitted purpose.  However, you may
+        only distribute the software according to [Distribution
+        License](#distribution-license) and make changes or new works
+        based on the software according to [Changes and New Works
+        License](#changes-and-new-works-license).
+        
+        ## Distribution License
+        
+        The licensor grants you an additional copyright license
+        to distribute copies of the software.  Your license
+        to distribute covers distributing the software with
+        changes and new works permitted by [Changes and New Works
+        License](#changes-and-new-works-license).
+        
+        ## Notices
+        
+        You must ensure that anyone who gets a copy of any part of
+        the software from you also gets a copy of these terms or the
+        URL for them above, as well as copies of any plain-text lines
+        beginning with `Required Notice:` that the licensor provided
+        with the software.  For example:
+        
+        > Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+        
+        ## Changes and New Works License
+        
+        The licensor grants you an additional copyright license to
+        make changes and new works based on the software for any
+        permitted purpose.
+        
+        ## Patent License
+        
+        The licensor grants you a patent license for the software that
+        covers patent claims the licensor can license, or becomes able
+        to license, that you would infringe by using the software.
+        
+        ## Noncommercial Purposes
+        
+        Any noncommercial purpose is a permitted purpose.
+        
+        ## Personal Uses
+        
+        Personal use for research, experiment, and testing for
+        the benefit of public knowledge, personal study, private
+        entertainment, hobby projects, amateur pursuits, or religious
+        observance, without any anticipated commercial application,
+        is use for a permitted purpose.
+        
+        ## Noncommercial Organizations
+        
+        Use by any charitable organization, educational institution,
+        public research organization, public safety or health
+        organization, environmental protection organization,
+        or government institution is use for a permitted purpose
+        regardless of the source of funding or obligations resulting
+        from the funding.
+        
+        ## Fair Use
+        
+        You may have "fair use" rights for the software under the
+        law. These terms do not limit them.
+        
+        ## No Other Rights
+        
+        These terms do not allow you to sublicense or transfer any of
+        your licenses to anyone else, or prevent the licensor from
+        granting licenses to anyone else.  These terms do not imply
+        any other licenses.
+        
+        ## Patent Defense
+        
+        If you make any written claim that the software infringes or
+        contributes to infringement of any patent, your patent license
+        for the software granted under these terms ends immediately. If
+        your company makes such a claim, your patent license ends
+        immediately for work on behalf of your company.
+        
+        ## Violations
+        
+        The first time you are notified in writing that you have
+        violated any of these terms, or done anything with the software
+        not covered by your licenses, your licenses can nonetheless
+        continue if you come into full compliance with these terms,
+        and take practical steps to correct past violations, within
+        32 days of receiving notice.  Otherwise, all your licenses
+        end immediately.
+        
+        ## No Liability
+        
+        ***As far as the law allows, the software comes as is, without
+        any warranty or condition, and the licensor will not be liable
+        to you for any damages arising out of these terms or the use
+        or nature of the software, under any kind of legal claim.***
+        
+        ## Definitions
+        
+        The **licensor** is the individual or entity offering these
+        terms, and the **software** is the software the licensor makes
+        available under these terms.
+        
+        **You** refers to the individual or entity agreeing to these
+        terms.
+        
+        **Your company** is any legal entity, sole proprietorship,
+        or other kind of organization that you work for, plus all
+        organizations that have control over, are under the control of,
+        or are under common control with that organization.  **Control**
+        means ownership of substantially all the assets of an entity,
+        or the power to direct its management and policies by vote,
+        contract, or otherwise.  Control can be direct or indirect.
+        
+        **Your licenses** are all the licenses granted to you for the
+        software under these terms.
+        
+        **Use** means anything you do with the software requiring one
+        of your licenses.
+License-File: LICENSE.md
+Keywords: oicana,pdf,typesetting,typst
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: oicana-native>=0.1.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Oicana
+
+Dynamic PDF Generation based on Typst.
+
+Oicana offers seamless PDF templating. Define your templates in Typst, specify dynamic inputs, and generate high quality PDFs from your application code.
+
+## Installation
+
+```bash
+uv add oicana
+```
+
+## Quick Start
+
+```python
+import json
+from oicana import Template, CompilationMode
+
+# Load your template
+with open("template.zip", "rb") as f:
+    template_bytes = f.read()
+
+# Create template and compile
+with Template(template_bytes) as template:
+    pdf = template.compile(
+        json_inputs={
+            "invoice": json.dumps({
+                "number": "INV-001",
+                "items": [{"name": "Service", "price": 100}]
+            })
+        },
+        export={"format": "pdf"},
+        mode=CompilationMode.PRODUCTION,
+    )
+
+    # Save the PDF
+    with open("output.pdf", "wb") as f:
+        f.write(pdf)
+```
+
+## Features
+
+- **Multi-platform**: Works on Linux, macOS, and Windows
+- **Powerful Layouting**: Full access to Typst's functionality
+- **Performant**: Native Rust performance via PyO3
+- **Type Safe**: Full type hints for IDE support
+- **Pythonic**: Context managers, dataclasses, and enums
+
+## Documentation
+
+For more information, visit [https://oicana.com/docs](https://oicana.com/docs)
+
+
+## Licensing
+
+Oicana is source-available under [PolyForm Noncommercial License 1.0.0](./LICENSE.md). You can use it for free in any noncommercial context.
+For commercial use, please visit [the Oicana website][oicana-website] for pricing options.
+
+
+[oicana-website]: https://oicana.com

oicana-0.1.0/README.md

@@ -0,0 +1,60 @@
+# Oicana
+
+Dynamic PDF Generation based on Typst.
+
+Oicana offers seamless PDF templating. Define your templates in Typst, specify dynamic inputs, and generate high quality PDFs from your application code.
+
+## Installation
+
+```bash
+uv add oicana
+```
+
+## Quick Start
+
+```python
+import json
+from oicana import Template, CompilationMode
+
+# Load your template
+with open("template.zip", "rb") as f:
+    template_bytes = f.read()
+
+# Create template and compile
+with Template(template_bytes) as template:
+    pdf = template.compile(
+        json_inputs={
+            "invoice": json.dumps({
+                "number": "INV-001",
+                "items": [{"name": "Service", "price": 100}]
+            })
+        },
+        export={"format": "pdf"},
+        mode=CompilationMode.PRODUCTION,
+    )
+
+    # Save the PDF
+    with open("output.pdf", "wb") as f:
+        f.write(pdf)
+```
+
+## Features
+
+- **Multi-platform**: Works on Linux, macOS, and Windows
+- **Powerful Layouting**: Full access to Typst's functionality
+- **Performant**: Native Rust performance via PyO3
+- **Type Safe**: Full type hints for IDE support
+- **Pythonic**: Context managers, dataclasses, and enums
+
+## Documentation
+
+For more information, visit [https://oicana.com/docs](https://oicana.com/docs)
+
+
+## Licensing
+
+Oicana is source-available under [PolyForm Noncommercial License 1.0.0](./LICENSE.md). You can use it for free in any noncommercial context.
+For commercial use, please visit [the Oicana website][oicana-website] for pricing options.
+
+
+[oicana-website]: https://oicana.com

oicana-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "oicana"
+version = "0.1.0"
+description = "PDF templating with Typst"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE.md" }
+authors = [
+    { name = "Oicana", email = "hello@oicana.com" }
+]
+dependencies = [
+    "oicana-native>=0.1.0",
+]
+keywords = ["oicana", "typst", "typesetting", "pdf"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://oicana.com"
+Repository = "https://github.com/oicana/oicana"
+Documentation = "https://oicana.com/docs"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "mypy>=1.0",
+    "ruff>=0.1.0",
+]
+test = [
+    "pytest>=7.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/oicana"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.uv.sources]
+oicana-native = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0",
+    "mypy>=1.0",
+    "ruff>=0.1.0",
+]
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

oicana-0.1.0/src/oicana/__init__.py

@@ -0,0 +1,28 @@
+"""Oicana - PDF templating with Typst."""
+from .template import Template, configure_automatic_cache_eviction, evict_cache
+from .types import (
+    BlobInput,
+    BlobInputDefinition,
+    CompilationMode,
+    ExportFormat,
+    ExportFormatPdf,
+    ExportFormatPng,
+    ExportFormatSvg,
+    JsonInputDefinition,
+)
+
+__version__ = "0.1.0a1"
+
+__all__ = [
+    "Template",
+    "configure_automatic_cache_eviction",
+    "evict_cache",
+    "CompilationMode",
+    "BlobInput",
+    "ExportFormat",
+    "ExportFormatPdf",
+    "ExportFormatPng",
+    "ExportFormatSvg",
+    "JsonInputDefinition",
+    "BlobInputDefinition",
+]

oicana-0.1.0/src/oicana/template.py

@@ -0,0 +1,229 @@
+"""Oicana Python integration."""
+from __future__ import annotations
+
+import json
+import uuid
+from typing import TYPE_CHECKING
+
+from oicana_native import (
+    BlobWithMetadata,
+    compile_template,
+    export_document,
+    get_file,
+    get_source,
+    inputs,
+    register_template,
+    remove_document,
+    remove_world,
+)
+from oicana_native import (
+    CompilationMode as NativeCompilationMode,
+)
+from oicana_native import (
+    configure_automatic_cache_eviction as _configure_automatic_cache_eviction,
+)
+from oicana_native import (
+    evict_cache as _evict_cache,
+)
+from oicana_native import (
+    set_validate_inputs as _set_validate_inputs,
+)
+
+from .types import BlobInput, CompilationMode, ExportFormat
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+class Template:
+    """Oicana template for PDF generation.
+
+    Example:
+        >>> with Template(template_bytes) as template:
+        ...     pdf = template.compile(
+        ...         json_inputs={"name": '{"value": "Alice"}'},
+        ...         export={"format": "pdf"}
+        ...     )
+    """
+
+    def __init__(
+        self,
+        template: bytes,
+        *,
+        json_inputs: dict[str, str] | None = None,
+        blob_inputs: dict[str, BlobInput] | None = None,
+        mode: CompilationMode = CompilationMode.DEVELOPMENT,
+    ) -> None:
+        """Initialize template.
+
+        Args:
+            template: Template zip file bytes
+            json_inputs: Initial JSON inputs (key -> JSON string)
+            blob_inputs: Initial blob inputs
+            mode: Compilation mode (development/production)
+        """
+        self._template_id = str(uuid.uuid4())
+        self._document_ids: list[str] = []
+
+        native_mode = (
+            NativeCompilationMode.Production
+            if mode == CompilationMode.PRODUCTION
+            else NativeCompilationMode.Development
+        )
+
+        native_json = json_inputs if json_inputs is not None else {}
+
+        native_blobs = {}
+        if blob_inputs:
+            for key, blob in blob_inputs.items():
+                meta_str = json.dumps(blob.metadata) if blob.metadata else "{}"
+                native_blobs[key] = BlobWithMetadata(blob.data, meta_str)
+
+        doc_id = register_template(
+            self._template_id,
+            template,
+            native_json,
+            native_blobs,
+            native_mode,
+        )
+        remove_document(doc_id)
+
+    def compile(
+        self,
+        *,
+        json_inputs: dict[str, str] | None = None,
+        blob_inputs: dict[str, BlobInput] | None = None,
+        export: ExportFormat = {"format": "pdf"},  # type: ignore[typeddict-item]
+        mode: CompilationMode = CompilationMode.PRODUCTION,
+    ) -> bytes:
+        """Compile template and export to the given format.
+
+        Args:
+            json_inputs: JSON inputs
+            blob_inputs: Blob inputs
+            export: Export format and configuration (pdf/png/svg)
+            mode: Compilation mode
+
+        Returns:
+            Compiled document bytes
+        """
+        native_mode = (
+            NativeCompilationMode.Production
+            if mode == CompilationMode.PRODUCTION
+            else NativeCompilationMode.Development
+        )
+
+        native_json = json_inputs if json_inputs is not None else {}
+
+        native_blobs = {}
+        if blob_inputs:
+            for key, blob in blob_inputs.items():
+                meta_str = json.dumps(blob.metadata) if blob.metadata else "{}"
+                native_blobs[key] = BlobWithMetadata(blob.data, meta_str)
+
+        doc_id = compile_template(
+            self._template_id,
+            native_json,
+            native_blobs,
+            native_mode,
+        )
+        self._document_ids.append(doc_id)
+
+        result = export_document(doc_id, json.dumps(export))
+
+        remove_document(doc_id)
+        self._document_ids.remove(doc_id)
+
+        return bytes(result)
+
+    def inputs(self) -> dict[str, Any]:
+        """Get input definitions from manifest.
+
+        Returns:
+            Dictionary with input definitions
+        """
+        inputs_json = inputs(self._template_id)
+        return json.loads(inputs_json)  # type: ignore[no-any-return]
+
+    def source(self, path: str) -> str:
+        """Get source file content.
+
+        Args:
+            path: File path in template
+
+        Returns:
+            File content as string
+        """
+        return get_source(self._template_id, path)  # type: ignore[no-any-return]
+
+    def file(self, path: str) -> bytes:
+        """Get binary file content.
+
+        Args:
+            path: File path in template
+
+        Returns:
+            File content as bytes
+        """
+        return bytes(get_file(self._template_id, path))
+
+    def set_validate_inputs(self, validate: bool) -> None:
+        """Enable or disable JSON schema validation for this template.
+
+        When enabled (the default), JSON inputs are validated against their schemas
+        before compilation.
+
+        Args:
+            validate: Whether to validate inputs against their JSON schemas.
+        """
+        _set_validate_inputs(self._template_id, validate)
+
+    def cleanup(self) -> None:
+        """Clean up cached resources."""
+        for doc_id in list(self._document_ids):
+            remove_document(doc_id)
+        self._document_ids.clear()
+
+        remove_world(self._template_id)
+
+    def __enter__(self) -> Template:
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        """Context manager exit with cleanup."""
+        self.cleanup()
+
+    def __del__(self) -> None:
+        """Destructor cleanup."""
+        try:
+            self.cleanup()
+        except Exception:
+            pass  # Best effort cleanup
+
+
+def configure_automatic_cache_eviction(max_age: int | None) -> None:
+    """Configure automatic cache eviction after each compilation.
+
+    Args:
+        max_age: Maximum age threshold, or None to disable:
+            - None - Disables cache eviction (cache never cleared)
+            - 0 - Clears all cache entries with every eviction
+            - 1 - Keeps only entries used since the last eviction
+            - n - Keeps entries used within the last n evictions
+            Default is 10.
+    """
+    _configure_automatic_cache_eviction(max_age)
+
+
+def evict_cache(max_age: int) -> None:
+    """Manually evict the cache with the given age threshold.
+
+    This directly calls the underlying eviction with the specified age,
+    regardless of the configured default age.
+
+    Args:
+        max_age: Maximum age threshold for eviction.
+            Entries with age >= this value will be removed.
+    """
+    _evict_cache(max_age)

oicana-0.1.0/src/oicana/types.py

@@ -0,0 +1,61 @@
+"""Type definitions for Oicana."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Literal, TypedDict, Union
+
+
+class CompilationMode(Enum):
+    """Template compilation mode."""
+
+    PRODUCTION = "production"
+    DEVELOPMENT = "development"
+
+
+class ExportFormatPdf(TypedDict):
+    """PDF export format."""
+
+    format: Literal["pdf"]
+
+
+class ExportFormatSvg(TypedDict):
+    """SVG export format."""
+
+    format: Literal["svg"]
+
+
+class ExportFormatPng(TypedDict):
+    """PNG export format."""
+
+    format: Literal["png"]
+    pixelsPerPt: float
+
+
+ExportFormat = Union[ExportFormatPdf, ExportFormatSvg, ExportFormatPng]
+
+
+@dataclass
+class BlobInput:
+    """Binary blob input with optional metadata."""
+
+    data: bytes
+    metadata: dict[str, Any] | None = None
+
+
+@dataclass
+class JsonInputDefinition:
+    """JSON input definition from manifest."""
+
+    key: str
+    schema: dict[str, Any]
+    development_value: dict[str, Any] | None = None
+
+
+@dataclass
+class BlobInputDefinition:
+    """Blob input definition from manifest."""
+
+    key: str
+    development_file: str | None = None
+    default_file: str | None = None

oicana-0.1.0/tests/testOutput/.gitignore

@@ -0,0 +1,3 @@
+*.png
+*.pdf
+*.svg

oicana-0.1.0/tests/test_e2e.py

@@ -0,0 +1,159 @@
+"""E2E tests for Oicana Python integration."""
+from pathlib import Path
+
+import pytest
+
+from oicana import BlobInput, CompilationMode, Template
+
+
+def asset(file: str) -> bytes:
+    """Load asset file."""
+    path = Path(__file__).parent.parent.parent.parent.parent / "assets" / file
+    return path.read_bytes()
+
+
+def template_file() -> bytes:
+    """Load E2E test template."""
+    path = (
+        Path(__file__).parent.parent.parent.parent.parent
+        / "e2e-tests"
+        / "template"
+        / "oicana-e2e-test-x.y.z.zip"
+    )
+    return path.read_bytes()
+
+
+def test_development() -> None:
+    """Test compilation in development mode with no inputs."""
+    template_bytes = template_file()
+    template = Template(template_bytes)
+
+    try:
+        image = template.compile(
+            export={"format": "png", "pixelsPerPt": 1.0},
+            mode=CompilationMode.DEVELOPMENT,
+        )
+
+        output_dir = Path(__file__).parent / "testOutput"
+        output_dir.mkdir(exist_ok=True)
+        (output_dir / "development.png").write_bytes(image)
+    finally:
+        template.cleanup()
+
+
+def test_production() -> None:
+    """Test compilation in production mode with required inputs."""
+    template_bytes = template_file()
+    template = Template(template_bytes)
+
+    try:
+        blob = asset("inputs/input.txt")
+        json_data = asset("inputs/input.json")
+
+        blob_inputs = {
+            "development-blob": BlobInput(
+                data=blob,
+                metadata={"image_format": "jpeg", "foo": 43, "bar": ["input", "two"]},
+            )
+        }
+        json_inputs = {"development-json": json_data.decode()}
+
+        image = template.compile(
+            json_inputs=json_inputs,
+            blob_inputs=blob_inputs,
+            export={"format": "png", "pixelsPerPt": 1.0},
+        )
+
+        output_dir = Path(__file__).parent / "testOutput"
+        output_dir.mkdir(exist_ok=True)
+        (output_dir / "production.png").write_bytes(image)
+    finally:
+        template.cleanup()
+
+
+def test_all_inputs() -> None:
+    """Test compilation with all possible inputs."""
+    template_bytes = template_file()
+    template = Template(template_bytes)
+
+    try:
+        blob = asset("inputs/input.txt")
+        json_data = asset("inputs/input.json")
+
+        blob_inputs = {
+            "default-blob": BlobInput(
+                data=blob,
+                metadata={"image_format": "jpeg", "foo": 42, "bar": ["input", "two"]},
+            ),
+            "development-blob": BlobInput(
+                data=blob,
+                metadata={"image_format": "jpeg", "foo": 43, "bar": ["input", "two"]},
+            ),
+            "both-blob": BlobInput(
+                data=blob,
+                metadata={"image_format": "jpeg", "foo": 44, "bar": ["input", "two"]},
+            ),
+        }
+        json_inputs = {
+            "default-json": json_data.decode(),
+            "development-json": json_data.decode(),
+            "both-json": json_data.decode(),
+        }
+
+        image = template.compile(
+            json_inputs=json_inputs,
+            blob_inputs=blob_inputs,
+            export={"format": "png", "pixelsPerPt": 1.0},
+        )
+
+        output_dir = Path(__file__).parent / "testOutput"
+        output_dir.mkdir(exist_ok=True)
+        (output_dir / "all-inputs.png").write_bytes(image)
+    finally:
+        template.cleanup()
+
+
+def test_explicit_development_mode_allows_compile_with_empty_inputs() -> None:
+    """Test that development mode allows compilation with empty inputs."""
+    template_bytes = template_file()
+    template = Template(template_bytes)
+
+    try:
+        template.compile(
+            export={"format": "png", "pixelsPerPt": 1.0},
+            mode=CompilationMode.DEVELOPMENT,
+        )
+    finally:
+        template.cleanup()
+
+
+def test_compile_defaults_to_production_mode() -> None:
+    """Test that compile defaults to production mode and fails without inputs."""
+    template_bytes = template_file()
+    template = Template(template_bytes)
+
+    try:
+        with pytest.raises(Exception, match="No value for the required input"):
+            template.compile(export={"format": "png", "pixelsPerPt": 1.0})
+    finally:
+        template.cleanup()
+
+
+def test_can_control_compilation_mode_when_registering() -> None:
+    """Test that compilation mode can be set during template registration."""
+    template_bytes = template_file()
+
+    with pytest.raises(Exception, match="No value for the required input"):
+        Template(template_bytes, mode=CompilationMode.PRODUCTION)
+
+
+def test_context_manager() -> None:
+    """Test that template works as context manager."""
+    template_bytes = template_file()
+
+    with Template(template_bytes) as template:
+        image = template.compile(
+            export={"format": "png", "pixelsPerPt": 1.0},
+            mode=CompilationMode.DEVELOPMENT,
+        )
+        assert len(image) > 0

oicana-0.1.0/tests/test_template.py

@@ -0,0 +1,20 @@
+"""Tests for the Template class."""
+import pytest
+
+from oicana import CompilationMode, Template
+
+
+def test_import() -> None:
+    """Test that the module can be imported."""
+    from oicana import BlobInput, ExportFormat
+
+    assert Template is not None
+    assert CompilationMode is not None
+    assert BlobInput is not None
+    assert ExportFormat is not None
+
+
+def test_compilation_mode() -> None:
+    """Test CompilationMode enum."""
+    assert CompilationMode.PRODUCTION.value == "production"
+    assert CompilationMode.DEVELOPMENT.value == "development"