reference.md

Reference

client.trigger_error_sentry_debug_get()

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.trigger_error_sentry_debug_get()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.health_check_health_check_get()

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.health_check_health_check_get()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

requirements

client.requirements.check(...)

🔌 Usage

from axiomatic import Axiomatic, UserRequirement

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.requirements.check(
    request=[
        UserRequirement(
            latex_symbol="latex_symbol",
            requirement_name="requirement_name",
            tolerance=1.1,
            value=1.1,
            units="units",
        )
    ],
)

⚙️ Parameters

request: typing.Sequence[UserRequirement]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

lean

client.lean.execute(...)

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.lean.execute(
    code="code",
)

⚙️ Parameters

code: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.lean.suggest(...)

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.lean.suggest(
    prompt="prompt",
    code_prefix="code_prefix",
)

⚙️ Parameters

prompt: str

code_prefix: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

formalization

client.formalization.formalize(...)

📝 Description

Formalize a query into a dictionary of constraints

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.formalization.formalize(
    query="query",
)

⚙️ Parameters

query: str

domain: typing.Optional[typing.Literal["PIC"]]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.formalization.validate(...)

📝 Description

Validate a set of values with respect to a dictionary of constraints

🔌 Usage

from axiomatic import Axiomatic, FormalizeResponse

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.formalization.validate(
    constraints=FormalizeResponse(
        variables={"key": "value"},
        expressions=[],
    ),
    values={"key": "value"},
)

⚙️ Parameters

constraints: FormalizeResponse

values: typing.Dict[str, str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Document

client.document.text(...)

📝 Description

Extracts text from documents

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.text()

⚙️ Parameters

file: `from future import annotations

core.File` — See core.File for more documentation

method: typing.Optional[str] — Method to use for text-only extraction.It uses a very simple pdf text extractor.

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.document.parse(...)

📝 Description

Extracts text from documents. It uses advanced pdf segmentation.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.parse()

⚙️ Parameters

file: `from future import annotations

core.File` — See core.File for more documentation

method: typing.Optional[str] — Method to use for text extraction

ocr: typing.Optional[bool] — Whether to use OCR

layout_model: typing.Optional[str] — Method for layout parsing

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.document.constants(...)

📝 Description

Extracts specific constants from documents

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.constants(
    constants=["constants"],
)

⚙️ Parameters

file: `from future import annotations

core.File` — See core.File for more documentation

constants: typing.List[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Tools

client.tools.schedule(...)

📝 Description

Schedule a job to execute python code for long running executions and return the standard output. If an error occurs, it will be returned in the error_trace field. The Following tools are currently supported: fdtd, femwell, optiland, jaxfem

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.tools.schedule(
    tool_name="tool_name",
    code="code",
)

⚙️ Parameters

tool_name: str

code: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.tools.status(...)

📝 Description

Get the status of the remote execution job for a given tool using the job_id

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.tools.status(
    job_id="job_id",
)

⚙️ Parameters

job_id: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.tools.list()

📝 Description

Get the list of available tools to execute code.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.tools.list()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

CodeExecution Python

client.code_execution.python.execute(...)

📝 Description

Execute python code, and return the standard output. If an error occurs, it will be returned in the error_trace field. Importing from the following modules is supported: gdsfactory, z3, json

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.code_execution.python.execute(
    code="code",
)

⚙️ Parameters

code: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Document Plot

client.document.plot.points(...)

📝 Description

Extracts points from plots

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.plot.points()

⚙️ Parameters

plot_img: `from future import annotations

core.File` — See core.File for more documentation

method: typing.Optional[int] — Can specify a specific method to extract points

plot_info: typing.Optional[str] — Can add specific plot info

get_img_coords: typing.Optional[bool] — Whether to get coords of points on image

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Document Equation

client.document.equation.user_variables()

📝 Description

Get all variables from the DB so the user can choose which variables they want to use in axtract for for their consistency checks.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.equation.user_variables()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.document.equation.from_pdf(...)

📝 Description

Extract equations from a document into the database

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.equation.from_pdf()

⚙️ Parameters

document: `from future import annotations

core.File` — See core.File for more documentation

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.document.equation.process(...)

📝 Description

Process all equations at once and return their annotation

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.equation.process(
    markdown="markdown",
)

⚙️ Parameters

markdown: str

images: typing.Optional[typing.Dict[str, str]]

interline_equations: typing.Optional[typing.Sequence[str]]

inline_equations: typing.Optional[typing.Sequence[str]]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.document.equation.validate(...)

📝 Description

Validates a set of variables against stored equations to check for inconsistencies. Returns validation results for each relevant equation.

🔌 Usage

from axiomatic import (
    Axiomatic,
    DictItem,
    EquationProcessingResponse,
    ResponseEquation,
    VariableRequirement,
)

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.equation.validate(
    variables=[
        VariableRequirement(
            symbol="symbol",
            name="name",
            value=1.1,
            units="units",
            tolerance=1.1,
        )
    ],
    paper_equations=EquationProcessingResponse(
        equations=[
            ResponseEquation(
                name="name",
                description="description",
                original_format="original_format",
                wolfram_expressions="wolfram_expressions",
                latex_symbols=[
                    DictItem(
                        key="key",
                        value="value",
                    )
                ],
                wolfram_symbols=["wolfram_symbols"],
                narrative_assumptions=["narrative_assumptions"],
                type=["type"],
                field_tags=["field_tags"],
            )
        ],
    ),
)

⚙️ Parameters

variables: typing.Sequence[VariableRequirement]

paper_equations: EquationProcessingResponse

include_internal_model: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Formalization Constraints

client.formalization.constraints.verify(...)

📝 Description

Verifies that a set of constraints are consistent

🔌 Usage

from axiomatic import Axiomatic, FormalizeResponse

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.formalization.constraints.verify(
    constraints=FormalizeResponse(
        variables={"key": "value"},
        expressions=[],
    ),
)

⚙️ Parameters

constraints: FormalizeResponse

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Formalization Solution

client.formalization.solution.find(...)

📝 Description

Finds a solution to a set of constraints provided partial values

🔌 Usage

from axiomatic import Axiomatic, FormalizeResponse

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.formalization.solution.find(
    constraints=FormalizeResponse(
        variables={"key": "value"},
        expressions=[],
    ),
    values={"key": 1},
)

⚙️ Parameters

constraints: FormalizeResponse

values: typing.Dict[str, SolutionBodyValuesValue]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Fso Lens

client.fso.lens.generate(...)

📝 Description

Generate GDS factory code to create a PIC component

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.fso.lens.generate(
    query="query",
)

⚙️ Parameters

query: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Lean Z3

client.lean.z_3.execute(...)

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.lean.z_3.execute(
    code="code",
)

⚙️ Parameters

code: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Pic Document

client.pic.document.summarize(...)

📝 Description

Summarize a PIC document

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.document.summarize(
    markdown="markdown",
    images={"key": "value"},
)

⚙️ Parameters

markdown: str

images: typing.Dict[str, str]

question: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Pic Circuit

client.pic.circuit.parse(...)

📝 Description

Parse a piece of text into a valid formal statement, if possible.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.parse(
    text="text",
)

⚙️ Parameters

text: str

informalize: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.informalize(...)

📝 Description

Informalize a formal statement about a circuit into a natural language text.

🔌 Usage

from axiomatic import Axiomatic, ParameterConstraint

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.informalize(
    statement=ParameterConstraint(
        text="text",
    ),
)

⚙️ Parameters

statement: Statement

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.validate(...)

📝 Description

Validates a set of statements against a netlist.

🔌 Usage

from axiomatic import Axiomatic, Netlist, StatementDictionary

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.validate(
    netlist=Netlist(),
    statements=StatementDictionary(),
)

⚙️ Parameters

netlist: Netlist

statements: StatementDictionary

mapping: typing.Optional[typing.Dict[str, typing.Optional[Computation]]]

use_ideal_component_models: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.formalize(...)

📝 Description

Formalize a query about a circuit into a dictionary of constraints. Extends previous statements if provided.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.formalize(
    query="query",
)

⚙️ Parameters

query: str

pdk: typing.Optional[PdkType]

statements: typing.Optional[StatementDictionary]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.mapping(...)

📝 Description

Map variables in the constraints to computations on the netlist.

🔌 Usage

from axiomatic import Axiomatic, Netlist, StatementDictionary

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.mapping(
    statements=StatementDictionary(),
    netlist=Netlist(),
)

⚙️ Parameters

statements: StatementDictionary

netlist: Netlist

max_iter: typing.Optional[int]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.generate(...)

📝 Description

Generate GDS factory code to create a circuit

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.generate(
    query="query",
)

⚙️ Parameters

query: str

max_iterations: typing.Optional[int]

llm_model: typing.Optional[str]

apply_orientation: typing.Optional[bool]

apply_placement: typing.Optional[bool]

apply_routing: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.refine(...)

📝 Description

Refine GDS factory code to create a circuit

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.refine(
    query="query",
)

⚙️ Parameters

query: str

max_iterations: typing.Optional[int]

feedback: typing.Optional[str]

code: typing.Optional[str]

llm_model: typing.Optional[str]

apply_orientation: typing.Optional[bool]

apply_placement: typing.Optional[bool]

apply_routing: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.optimize(...)

📝 Description

Optimize a PIC circuit with given cost and constraints

🔌 Usage

from axiomatic import Axiomatic, Netlist, StatementDictionary

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.optimize(
    netlist=Netlist(),
    statements=StatementDictionary(),
)

⚙️ Parameters

netlist: Netlist

statements: StatementDictionary

parameters: typing.Optional[typing.Sequence[Parameter]]

mapping: typing.Optional[typing.Dict[str, typing.Optional[Computation]]]

config: typing.Optional[OptimizeConfig]

use_ideal_component_models: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.placementoptimize(...)

📝 Description

Optimizes the placement of a circuit

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.placementoptimize(
    netlist={"key": "value"},
)

⚙️ Parameters

netlist: typing.Dict[str, typing.Optional[typing.Any]]

method: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.verify(...)

📝 Description

Verifies that the code for a circuit

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.verify(
    code="code",
)

⚙️ Parameters

code: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.get_sax_spectrum(...)

📝 Description

Get the spectrum of a circuit over various wavelengths and settings

🔌 Usage

from axiomatic import Axiomatic, Netlist

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.get_sax_spectrum(
    netlist=Netlist(),
    port_pairs=[[]],
    settings={"key": "value"},
    wls=[1.1],
)

⚙️ Parameters

netlist: Netlist

port_pairs: typing.Sequence[typing.Sequence[typing.Optional[typing.Any]]]

settings: Settings

wls: typing.Sequence[float]

use_ideal_component_models: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.circuit.get_optimizable_parameters(...)

📝 Description

Gets the optimizable parameters of a circuit.

🔌 Usage

from axiomatic import Axiomatic, Netlist

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.circuit.get_optimizable_parameters(
    netlist=Netlist(),
)

⚙️ Parameters

netlist: Netlist

get_key_parameters: typing.Optional[bool]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Pic Component

client.pic.component.generate(...)

📝 Description

Generate GDS factory code to create a PIC component

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.component.generate(
    query="query",
)

⚙️ Parameters

query: str

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

client.pic.component.refine(...)

📝 Description

Refine GDS factory code to create a circuit

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.pic.component.refine(
    query="query",
)

⚙️ Parameters

query: str

feedback: typing.Optional[str]

code: typing.Optional[str]

request_options: typing.Optional[RequestOptions] — Request-specific configuration.

Requirements DataFiles

client.requirements.data_files.retrieve()

📝 Description

Provides database for user menu later used to compose reqs in AXtract

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.requirements.data_files.retrieve()

⚙️ Parameters

request_options: typing.Optional[RequestOptions] — Request-specific configuration.