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.

lean

client.lean.formalize(...)

🔌 Usage

from axiomatic import Axiomatic

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

⚙️ Parameters

query: str

universe: typing.Optional[str]

k_best: typing.Optional[int]

max_attempts: typing.Optional[int]

verbose: typing.Optional[bool]

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

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.

client.lean.prove(...)

🔌 Usage

from axiomatic import Axiomatic

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

⚙️ Parameters

code: str

universe: typing.Optional[str]

k_best: typing.Optional[int]

max_attempts: typing.Optional[int]

verbose: typing.Optional[bool]

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 files. 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[ParseMethods] — 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.parse_from_arxiv_url(...)

📝 Description

Extracts text from arxiv urls. It uses advanced pdf segmentation.

🔌 Usage

from axiomatic import Axiomatic

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

⚙️ Parameters

arxiv_url: typing.Optional[str]

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.

DigitalTwin

client.digital_twin.optimize(...)

📝 Description

Fits a digital twin model to input data using numerical optimization.

Accepts parameter guesses, bounds, inputs, targets, and constants — all with units —
and returns the optimized parameters that minimize the model's error using a selected cost function.

Args:
    OptimizerBody: The input data and optimization parameters.
Returns:
    OptimizerResult: The result of the optimization.

🔌 Usage

from axiomatic import (
    Axiomatic,
    NamedQuantity,
    NamedQuantityList,
    ParameterBound,
    Quantity,
)

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.digital_twin.optimize(
    model_name="RingModulatorSiliconOnInsulatorAllPassWavelength",
    parameters=[
        NamedQuantity(
            name="name",
            value=Quantity(
                magnitude=1.1,
                unit="unit",
            ),
        )
    ],
    parameter_bounds=[
        ParameterBound(
            name="name",
            lower=Quantity(
                magnitude=1.1,
                unit="unit",
            ),
            upper=Quantity(
                magnitude=1.1,
                unit="unit",
            ),
        )
    ],
    constants=[
        NamedQuantity(
            name="name",
            value=Quantity(
                magnitude=1.1,
                unit="unit",
            ),
        )
    ],
    input=NamedQuantityList(
        name="name",
        unit="unit",
        magnitudes=[1.1],
    ),
    target=NamedQuantityList(
        name="name",
        unit="unit",
        magnitudes=[1.1],
    ),
)

⚙️ Parameters

model_name: ModelNames

parameters: typing.Sequence[NamedQuantity]

parameter_bounds: typing.Sequence[ParameterBound]

constants: typing.Sequence[NamedQuantity]

input: NamedQuantityList

target: NamedQuantityList

tolerance: typing.Optional[float]

max_time: typing.Optional[int]

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

client.digital_twin.evaluate(...)

📝 Description

Evaluate Digital Twin Model

This endpoint takes model parameters and target functions as input,
then returns the evaluated values for each target function using the
specified model. It can be used for model validation, simulation,
and prediction tasks.

🔌 Usage

from axiomatic import (
    Axiomatic,
    EvaluatePoint,
    InputValues,
    NamedQuantity,
    Quantity,
)

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.digital_twin.evaluate(
    model_name="RingModulatorSiliconOnInsulatorAllPassWavelength",
    parameters=[
        NamedQuantity(
            name="name",
            value=Quantity(
                magnitude=1.1,
                unit="unit",
            ),
        )
    ],
    target_function="delta_n_eff",
    target_unit="target_unit",
    input_values=InputValues(
        name="name",
        unit="unit",
        points=[
            EvaluatePoint(
                value_x=1.1,
                percentage_coord_x=1.1,
                value_y=1.1,
                percentage_coord_y=1.1,
            )
        ],
    ),
)

⚙️ Parameters

model_name: ModelNames

parameters: typing.Sequence[NamedQuantity]

target_function: Targets

target_unit: str

input_values: InputValues

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

client.digital_twin.list_models()

📝 Description

Retrieves a list of available digital twin models and their parameter definitions.

Returns the name, description (if available), and parameter details
(name, unit, lower and upper bound) for each model.

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.digital_twin.list_models()

⚙️ 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

v2: typing.Optional[bool] — Get v2 of plot parser output. (v1 will be deprecated soon)

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

client.document.plot.split(...)

📝 Description

Splits a plot into multiple subplots if they exist

🔌 Usage

from axiomatic import Axiomatic

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

⚙️ Parameters

plot_img: `from future import annotations

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

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

Document Expression

client.document.expression.validate(...)

📝 Description

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

🔌 Usage

from axiomatic import (
    Axiomatic,
    Expression,
    ExpressionProcessingResponse,
    Symbol,
    ValidationRequirement,
    ValidationResult,
)

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.expression.validate(
    variables=[
        ValidationRequirement(
            symbol=Symbol(
                name="name",
                wolfram_format="wolfram_format",
                latex_representation="latex_representation",
                dimension="dimension",
                description="description",
                type="scalar",
                validations={
                    "key": ValidationResult(
                        is_valid=True,
                        message="message",
                    )
                },
            ),
            value=1.1,
        )
    ],
    paper_expressions=ExpressionProcessingResponse(
        expressions=[
            Expression(
                name="name",
                description="description",
                original_format="original_format",
                wolfram_expression="wolfram_expression",
                symbols={
                    "key": Symbol(
                        name="name",
                        wolfram_format="wolfram_format",
                        latex_representation="latex_representation",
                        dimension="dimension",
                        description="description",
                        type="scalar",
                        validations={
                            "key": ValidationResult(
                                is_valid=True,
                                message="message",
                            )
                        },
                    )
                },
                narrative_assumptions=["narrative_assumptions"],
                exp_validations={
                    "key": ValidationResult(
                        is_valid=True,
                        message="message",
                    )
                },
            )
        ],
    ),
)

⚙️ Parameters

variables: typing.Sequence[ValidationRequirement]

paper_expressions: ExpressionProcessingResponse

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

client.document.expression.process_depricated_version(...)

📝 Description

Process all expressions at once and return their annotation

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.expression.process_depricated_version(
    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.expression.process(...)

📝 Description

process expressions from document in parallel

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.expression.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.expression.sympy_plot(...)

📝 Description

generate a sympy plot for a given expression

🔌 Usage

from axiomatic import (
    Axiomatic,
    Expression,
    Symbol,
    SympyPlotVariable,
    ValidationResult,
)

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.document.expression.sympy_plot(
    expression=Expression(
        name="name",
        description="description",
        original_format="original_format",
        wolfram_expression="wolfram_expression",
        symbols={
            "key": Symbol(
                name="name",
                wolfram_format="wolfram_format",
                latex_representation="latex_representation",
                dimension="dimension",
                description="description",
                type="scalar",
                validations={
                    "key": ValidationResult(
                        is_valid=True,
                        message="message",
                    )
                },
            )
        },
        narrative_assumptions=["narrative_assumptions"],
        exp_validations={
            "key": ValidationResult(
                is_valid=True,
                message="message",
            )
        },
    ),
    variables=[
        SympyPlotVariable(
            symbol="symbol",
            span=[1.1],
            feature="x",
        )
    ],
)

⚙️ Parameters

expression: Expression

variables: typing.Sequence[SympyPlotVariable]

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.z3.execute(...)

🔌 Usage

from axiomatic import Axiomatic

client = Axiomatic(
    api_key="YOUR_API_KEY",
)
client.lean.z3.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]]]

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]

return_cell: 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]

return_cell: 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]

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(),
    wavelengths=[1.1],
)

⚙️ Parameters

netlist: Netlist

wavelengths: typing.Sequence[float]

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

settings: typing.Optional[Settings]

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.

client.pic.circuit.update_code(...)

📝 Description

Update GDS code to match the netlist

🔌 Usage

from axiomatic import Axiomatic, Netlist

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

⚙️ Parameters

code: str

netlist: Netlist

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.

FilesExpand file tree

reference.md

Latest commit

History

reference.md

File metadata and controls

Reference

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

lean

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

🔌 Usage

⚙️ Parameters

formalization

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

Document

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

Tools

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

DigitalTwin

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

CodeExecution Python

📝 Description

🔌 Usage

⚙️ Parameters

Document Plot

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

Document Expression

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage