o s::j @sRUdZddlmZddlmZmZmZmZmZddl Z ddl Z ddl m mZddlZddlmZmZee je jeeeeeeeeeeeedf Zee jjee jjiZde d<dEd d Z!dFddZ" dGdHddZ#dIddZ$ee j%efZ&dJd!d"Z'dKdLd'd(Z(dMd,d-Z)d.dd/dNd8d9Z*dd:dOd?d@Z+GdAdBdBZ,GdCdDdDZ-dS)PaGraph builder for constructing ONNX IR graphs imperatively. This module provides imperative builders for constructing ONNX IR graphs with automatic constant promotion, type casting, and shape inference. The GraphBuilder class enables programmatic construction of graphs with proper scoping, constant management, and node creation. The OpBuilder class provides dynamic op dispatching via attribute access. ) annotations)AnyCallableMappingSequenceUnionN)_inlinerparam_manipulationzdict[type, ir.DataType]_PYTHON_TYPE_TO_DTYPE element_typetypereturnstrcCst|}|dur |SdS)zEReturn a short type suffix for naming constants based on Python type.N)r get short_name)r dtyperc/home/nk/hobo-godmode/plappi-mvp/.venv/lib/python3.10/site-packages/onnxscript/_internal/builder.py _type_suffix-s rr ir.DataTypecCs|S)zEReturn a short type suffix for naming constants based on ir.DataType.)rrrrr _dtype_suffix3rvalue#int | float | bool | str | Sequence type_suffixnumintcCsLt|tr d|St|tttfr!|rd|d|Sd|Sd|S)aGenerate a descriptive name for a constant value. Args: value: The constant value type_suffix: Type suffix (e.g., 'F', 'I64') num: A number used for generating unique names for str/sequences Returns: A name string for the constant const_str_const__ const_1d_) isinstancerrfloatbool)rrrrrr_constant_name8s  r&graphir.GraphNonec sdd|jDfddt|jD}|jdd}g}|D]7}|j}|dur3td|jd t j dd gt d t j j |g|g|d |jd }|j|j||q!|r~|dkrf|dnd}|durt|||dS|D] }||qvdSdS)u.Replace every initializer in *graph* with a ``Constant`` node. ONNX ``ir.Function`` bodies do not support initializers — all values must be produced by nodes. Call this on the function-body graph **before** wrapping it in :class:`ir.Function` so that any constant initializers (e.g. from Python literals promoted by :class:`GraphBuilder`) become valid ``Constant`` nodes. The function preserves ``ir.Value`` identity: it reuses each existing ``ir.Value`` object as the output of the new ``Constant`` node so that all downstream references remain valid. Graph inputs that are *also* registered as initializers (the standard ONNX pattern for optional inputs with default values) are skipped because they are explicit function parameters, not embedded constants. cSsh|]}t|qSrid.0vrrr _z1lift_initializers_to_constants..csg|] }t|vr|qSrr*r,graph_input_setrr `sz2lift_initializers_to_constants..rNz Initializer z has no const_valueConstantr initializer_)inputs attributesoutputsversionnamer)r7list initializersvalues opset_importsr const_value ValueErrorr;irNodeAttr AttributeTypeTENSORpopappend num_nodesnode insert_before) r'to_lift opset_version new_nodesrtensorrJfirst_existingnrr1rlift_initializers_to_constantsNs:     rRspecTypeSpecir.TypeAndShapecCsbt|tjr|St|dr'|}t|tjs%tt|dt|d|Stdt|d)a|Convert a *TypeSpec* to an :class:`ir.TypeAndShape`. Accepts an :class:`ir.TypeAndShape` directly, or any object with a ``to_ir_type_and_shape()`` method (e.g. a :class:`~onnxscript.onnx_types.TensorType` subclass such as ``FLOAT[1024]`` or ``FLOAT['M', 'N']``). .. deprecated:: Use :func:`make_value` or construct ``ir.Value`` directly instead. to_ir_type_and_shapez!.to_ir_type_and_shape() returned z, expected ir.TypeAndShape.zPExpected ir.TypeAndShape or an object with a to_ir_type_and_shape() method, got .)r#rB TypeAndShapehasattrrV TypeErrorr )rSresultrrr_resolve_type_specs   r\r; type_specTypeSpec | Noneir.ValuecCs0|durt|}tj||j|jdStj|dS)aCreate an :class:`ir.Value` from a name and optional :data:`TypeSpec`. Similar to :func:`onnx_ir.val` but accepts a :data:`TypeSpec` (e.g. ``FLOAT[3, 4]``) instead of separate *dtype* and *shape* arguments. Example:: x = make_value("x", FLOAT[3, 4]) y = make_value("y") # untyped Args: name: The value name. type_spec: Optional type specification. Accepts an :class:`ir.TypeAndShape`, or a :class:`~onnxscript.onnx_types.TensorType` subclass (e.g. ``FLOAT[3, 4]``). Returns: A fresh :class:`ir.Value` with the given name and optional type/shape. N)r;r shaper;)r\rBValuer r`)r;r]tsrrr make_values rdr7Sequence[ir.Value | None],tuple[list[ir.Value | None], list[ir.Value]]cCst|}g}t|D]7\}}|dur|tjd|dq |dur.td|jd|jdur ir.Value | Sequence[ir.Value]``. It is called once with freshly created placeholder inputs to record the graph topology. ``None`` entries in *inputs* are passed through as ``None`` to support optional inputs. inputs: A :class:`Sequence` of :class:`ir.Value` (or ``None`` for absent optional inputs). Each ``ir.Value`` should be freshly created with a name and optional type/shape. For ``None`` entries, placeholder values are declared as formal graph inputs, while ``None`` is passed to *trace_function* for the corresponding argument position. outputs: A :class:`Sequence` of :class:`ir.Value` objects declaring the expected outputs. After tracing, the name and type of each declared output are applied to the corresponding returned value. opset_imports: Opset version map for the subgraph (e.g. ``{"": 23}``). name: Name of the resulting :class:`ir.Graph`. parent: Optional parent :class:`GraphBuilder`. When provided, the sub-builder's ``_root`` points to the root builder of the parent, so that :meth:`Parameter._realize` registers initializers in the root (main) graph rather than the subgraph. Returns: An :class:`ir.Graph` whose inputs and outputs are populated and whose nodes record the operations traced by *trace_function*. This graph can be passed directly as a graph-valued attribute (e.g. the ``body`` attribute of a ``Scan`` or ``Loop`` node). )r;r7r9nodesr?roNztrace_function returned z output(s), but z were declared in outputs.zOutput z: traced type z conflicts with declared type rW)rmrBGraph GraphBuilderr< _scope_stackopr#rlenrAzipr;r r` merge_shapesr9extend) rpr7r9r?r;rorjrkrn sub_builder trace_outputs returned_val declared_valrrr build_graphsL 5         r)r8domainr80Mapping[str, ir.Attr] | Sequence[ir.Attr] | None ir.Functionc Cst|\}}tj|gg|d|d}t|} || jg|R} | dur:t| ts,| g} |jr3td|j | n|jsAtdt ||durLi} nt|t rVt |} ndd|D} tj |||| dS) a(Build an :class:`ir.Function` by tracing *trace_function*. This utility handles all boilerplate for constructing an ``ir.Function``: graph creation, input/output wiring, initializer lifting (so that Python literals work correctly inside function bodies), and attribute packaging. Example:: fn = build_function( lambda op, x, y: op.Add(x, y), [make_value("x"), make_value("y")], domain="com.example", name="MyAdd", opset_imports={"": 23}, ) Args: trace_function: A callable with signature ``(op: OpBuilder, *inputs: ir.Value | None) -> ir.Value | Sequence[ir.Value] | None``. It is called once to trace the function body. Return value(s) become function outputs. If ``None`` is returned, the function uses whatever outputs were appended to ``graph.outputs`` by the trace function directly. inputs: A :class:`Sequence` of :class:`ir.Value` (or ``None`` for absent optional inputs). ``None`` entries are represented by placeholder formal inputs in the generated function signature, while ``None`` is passed through to *trace_function* in the corresponding positions so the body can branch with ``if x is None``. domain: Function domain (e.g. ``"com.microsoft"``). name: Function name (e.g. ``"LinearAttention"``). attributes: Function-level attributes. Accepts a :class:`Mapping` from name to :class:`ir.Attr`, a :class:`Sequence` of :class:`ir.Attr`, or ``None``. opset_imports: Opset version map (e.g. ``{"": 23}``). Returns: An :class:`ir.Function` with initializers automatically lifted to ``Constant`` nodes. _body)r7r9rtr;r?Nzetrace_function both returned output values and appended to graph.outputs. Use one approach, not both.zMtrace_function returned None and did not append any outputs to graph.outputs.cSsi|]}|j|qSrra)r-arrr r0z"build_function..)rr;r'r8)rmrBrvrwryr#rr9rAr}rRrdictFunction) rpr7rr;r8r?rjrkr'gbr attr_dictrrrbuild_functionEsD 1   rc@seZdZdZdddd d ZddddZedddZedddZedddZ edddZ edddZ ddd dd(d)Z  ddddd*dd5d6Z dd8d9Zdd;d<Z ddd?d@Z AdddFdGZddJdKZddRdSZddVdWZddYdZZdd]d^Zd_d`ddcddZ A  dddedfZddgddldmZddAdnddqdrZdddudvZddwdxZddzd{Zdd|d}Zdd~dZdddZ dddZ!dddZ"dddZ#dS)rwzxImperative builder for constructing ONNX IR graphs with automatic constant promotion, type casting, and shape inference.Nrur'r(rorsr r)cCsl||_||_|dur |jn||_d|jvrtd|jd}|d||_g|_|dur4i|_i|_ dSdS)Nrz1Input graph does not have an import for domain "") _graph_parent_rootr?rAopset _op_builderrx_constant_cache _functions)selfr'rorMrrr__init__s   zGraphBuilder.__init__r4rrr:r OpBuildercCs t|||S)z:Create an OpBuilder bound to the given domain and version.)r)rrr:rrrrs zGraphBuilder.opsetcC|jSN)rrrrrryzGraphBuilder.opcCr)z4The parent builder, or None for a top-level builder.)rrrrrrozGraphBuilder.parentcCr)z1The root (top-level) builder in the parent chain.)rrrrrrootrzGraphBuilder.rootcCrr)rrrrrr'rzGraphBuilder.graph(dict[ir.OperatorIdentifier, ir.Function]cC|jjSr)rrrrrr functionsrzGraphBuilder.functionsT)qualifyrOir.TensorProtocolr; str | Nonerr%r_cCsT|dur|j}|r||}t|j}tj||t|j|d}|jj ||S)aTRegister a tensor as a graph initializer in the **root** graph. Initializers created through this method are stored in the root graph so that inner scopes (subgraphs) can reference them via ONNX's outer-scope visibility rules. This does not apply to the ONNX default-input pattern created via :meth:`input` with ``const_value``, which registers an initializer on the owning graph. For function bodies (which cannot have initializers), apply :func:`lift_initializers_to_constants` before wrapping in :class:`ir.Function`. N)r;r`r r@) r;_qualify_initializer_namerBShaper`rb TensorTyperrrregister_initializer)rrOr;rr`rrrr initializers  zGraphBuilder.initializer)r r@metadata_propsrir.DataType | Noner`,ir.Shape | Sequence[int | str | None] | Noner ir.TypeProtocol | Noner@ir.TensorProtocol | Nonerdict[str, str] | NonecCs<tj||||||d}|jj||dur|j||S)aCreate an input to the graph and return the corresponding ir.Value. Args: name: The name of the value. dtype: The data type of the TensorType of the value. This is used only when type is None. shape: The shape of the value. type: The type of the value. Only one of dtype and type can be specified. const_value: The constant tensor that initializes the value. Supply this argument when you want to create an initializer. The type and shape can be obtained from the tensor. metadata_props: The metadata properties that will be serialized to the ONNX proto. Returns: A Value object. )r;rr`r r@rN)rBvalrr7rHr)rr;rr`r r@rrrrrinputs zGraphBuilder.inputrcCs|r||_|jj|dS)zAdd an output to the graph. Args: value: The ir.Value to add as an output. name: The name to assign to the output value. If None, no renaming is done. N)r;rr9rH)rrr;rrr add_outputszGraphBuilder.add_output VALUE_LIKEc s|j}tttttfrO|durtt}|f}||j vr%|j |S|dur-t |nd}t |t |j }t j||d}|j||dd}||j |<|StttfrrtfddDrtdttttfr|dur{ttd}t|f}||j vr|j |S|durt |nd}t |t |j }t jt||d}|j||dd}||j |<|S|t j|d S) aMaterialise a constant as an initializer in the **root** graph. Child builders delegate to the root so that all constant initializers live in the root graph. For subgraphs this is correct because ONNX allows inner scopes to reference outer-scope initializers. For function bodies (which cannot reference outer initializers) callers should apply :func:`lift_initializers_to_constants` before wrapping the graph in :class:`ir.Function`. Nr)rr;F)r;rc3s"|] }t|tdVqdS)rN)r#r r,rrr Bs z7GraphBuilder._get_or_create_constant..rr)rr#rr$r%rr rr rrr&rzrBrOrr<tupleall) rrrr cache_keyrr;rOir_valuerrr_get_or_create_constant&sB         z$GraphBuilder._get_or_create_constant like_typeir.Value | NonecCslt|tjr|S|dur|S|dur|jdur|jjnd}|duo$|du}|||}|r4|j||}|S)a%Convert a permissible input (for a call to an op) into an ir.Value. Permissible values include ir.Value as well as python constants that can be converted into ONNX constant tensors. For constant values, the like_type is used to determine the target onnx type. N)r#rBrbr rrryCastLike)rrrrneeds_dynamic_castrrrr_input_to_ir_valueUs  zGraphBuilder._input_to_ir_valuerr9int | Sequence[str | ir.Value]op_typerqcst|trDj|dkrtd||dkr/r"dn}tj|dgSfddt|D}fdd|DSg}|D]-}t|tjr`|j rZ|j |_ | |qHt|t rr| tj|dqHt d |S) Nrz,Number of outputs must be non-negative, got r4r!racs2g|]}rdd|nd|qS)r!rr-rl)countrrrr3|s$z/GraphBuilder._adapt_outputs..csg|] }tj|dqS)ra)rBrb_qualify_value_name)r-rQrrrr3szOutput type not supported.) r#rr'rIrArBrbrranger;rHrrZ)rr9rr;namesadapted_outputsoutputr)rrrr_adapt_outputsqs*      zGraphBuilder._adapt_outputs int | Noneonnx.defs.OpSchema | NonecCs8|durz tj|||WStjjyYdSwdSr)onnxdefs get_schema SchemaError)rrrr:rrr _get_schemaszGraphBuilder._get_schemaschemar7-Sequence[ir.Value | ir.TensorProtocol | None]kwargsdict[str, Any]=tuple[Sequence[ir.Value | ir.TensorProtocol], dict[str, Any]]cCs6|dur||fStjj|}tj|t||dddS)NF) fill_defaultsallow_extra_args)rBschemas OpSignaturefrom_op_schemar (separate_input_attributes_from_argumentsr<)rrr7r op_signaturerrr_partition_inputs_attributessz)GraphBuilder._partition_inputs_attributesSequence[VALUE_LIKE]rec s|dur fdd|DS|j}ig}t|D]W\}}|t|kr'||}n,|rD|djtjjjjkrD|d}|j sC| |dfqnt dt|dt|d|j }d|vrh|vrht |tjrh||<| ||fqdfd d fdd|DS)akUses schema specification to support a limited form of auto-casting. * Scalars are promoted to tensors. * Further. they are cast to the required type when used in ops with other tensor inputs that are required to be of same type. Thus, in "A+1" or "Add(A, 1)", the value 1 will be converted to the same type as A. Ncg|]}|qSrrrrrrr3z-GraphBuilder._cast_inputs..zNumber of actual parameters z% exceeds number of formal parameters rW(typevarrr rcs4|durdS|dur|S|}||Sr)rr)xr type_like)r type_bindingsrradapts    z(GraphBuilder._cast_inputs..adaptcsg|] \}}||qSrr)r-rr)rrrr3s)rrr r)r7rhrzoptionrrOpSchemaFormalParameterOptionVariadicis_homogeneousrHrAtype_strr#rBrb) rrr7expected_inputs args_typevarsrlrexpectedrr)rrrr _cast_inputss6     zGraphBuilder._cast_inputsr8cCs~|dur|SiSrr)rrr8rrr_cast_attributesszGraphBuilder._cast_attributesrJir.NodecCs(|j|tj|gt|dS)zIAppend a node to the graph, run constant propagation and shape inference.N)r'rH onnxscript optimizerbasic_constant_propagation inference infer_outputs)rrJrrradd_nodes zGraphBuilder.add_nodernrarprcCst|||t|jj||dS)aRBuild an :class:`ir.Graph` suitable for use as a graph-valued attribute. The subgraph inherits the opset version from this :class:`GraphBuilder`. It is particularly useful for constructing the body graphs of control-flow ops such as ``Scan``, ``Loop``, and ``If``. Example - building a Scan body that adds two sequences element-wise:: body = graph_builder.subgraph( lambda op, x, y: op.Add(x, y), inputs=[make_value("x", FLOAT[...]), make_value("y", FLOAT[...])], outputs=[make_value("sum", FLOAT[...])], ) Args: trace_function: A callable with signature ``(op: OpBuilder, *inputs: ir.Value | None) -> ir.Value | Sequence[ir.Value]``. It is called once with freshly created placeholder inputs to record the graph topology. inputs: A :class:`Sequence` of :class:`ir.Value` (or ``None`` for absent optional inputs). Each ``ir.Value`` should be freshly created with a name and optional type/shape. outputs: A :class:`Sequence` of :class:`ir.Value` objects declaring the expected outputs. name: Name of the resulting :class:`ir.Graph`. Returns: An :class:`ir.Graph` whose inputs and outputs are populated and whose nodes record the operations traced by *trace_function*. This graph can be passed directly as a graph-valued attribute (e.g. the ``body`` attribute of a ``Scan`` or ``Loop`` node). )r?r;ro)rrrr?)rrpr7r9r;rrrrns( zGraphBuilder.subgraphc Cs|j}||d|}|||} ||||} || ||\}} || |}|| | } tj ||| p8d|| ||d} | | j d<t | | j d<t || j d<|| t| jdkrg| jS| jdS) zKCreate an ONNX node and add it to the graph, returning its output value(s)._node_N)r8rr9r:r; namespacepkg.onnxscript.class_hierarchypkg.onnxscript.name_scopesr4r)r'rI_qualify_node_namerrrrrrBrJ_build_namespacerrepr_scope_classes _scope_namesrrzr9) rrr7rrr:r9r node_name output_valuesrr8rJrrrcall_ops*      zGraphBuilder.call_op_outputsfunction%ir.Function | onnxscript.OnnxFunctionr%int | Sequence[str | ir.Value] | Nonec s(t|tjr |j}nt|tjr|}|j}ntd|dur%t|j } ||j }fdd|D}j } |j d|} tj|j ||pMd||j| |jd} | jd<t| jd<t| jd <| |jj|<t| j d krd St| j d kr| j S| j d S) z*Call a function as a single function node.:Function must be an ir.Function or onnxscript.OnnxFunctionNcrrr)r-argrrrr3\rz%GraphBuilder.call..r)rr7r8r9rr;overloadrrrrrr4)r#rBrr'r OnnxFunction function_irrZrzr9rr;rIrrJrr rrrrrrrr identifier) rrrargsrr'r adapted_argsrrrJrrrcallGs:      zGraphBuilder.callr_prefixSequence[str] | Nonercst|tjr |j}nt|tjr|jdd}ntd|durBt|t|j kr8t d|dt|j dfdd|D}ng}|rK |j } |jd |d } tj|||| d \} } d d | D} | D]} | j D]}|jrt|| vr|j|_qu| qp|rt| |D] \}}|dur||_qn| D]}|dur|jr|j|_q|rt| dkrdSt| dkr| S| dS)NT)allow_outer_scope_valuesr zNumber of rovided output names z+ does not match number of function outputs rWcrr)r)r-r;rrrr3s z,GraphBuilder.call_inline..r/)prefixcSsh|] }|durt|qSrr*r,rrrr/sz+GraphBuilder.call_inline..rrr4)r#rBrr'rrclonerZrzr9rA push_modulerIrr;r instantiater+rrr{ pop_module)rrrrrrr'desired_output_namesrnode_name_prefixrtr9output_value_idsrJr output_valr;rrr call_inlinevsV        zGraphBuilder.call_inlinemodule class_namecCs|j||fdS)zPush a new module scope onto the stack. Args: module: The attribute name of the module (e.g. ``"layers.0"``). class_name: The qualified class name (e.g. ``"Gemma3DecoderLayer"``). N)rxrH)rr#r$rrrrszGraphBuilder.push_modulecCs|jstd|jdS)z/Pop the most recent module scope off the stack.z5Cannot pop_module: no module context has been pushed.N)rx RuntimeErrorrGrrrrrszGraphBuilder.pop_module list[str]cCdd|jDS)z?Return the list of module attribute names in the current scope.cSsg|]\}}|qSrrr-r;r!rrrr3r0z-GraphBuilder._scope_names..rxrrrrrzGraphBuilder._scope_namescCr')z4Return the list of class names in the current scope.cSsg|]\}}|qSrr)r-r!clsrrrr3r0z/GraphBuilder._scope_classes..r)rrrrrr*zGraphBuilder._scope_classescCr')z3Return non-empty module names for qualifying names.cSsg|]\}}|r|qSrrr(rrrr3sz2GraphBuilder._scope_name_parts..r)rrrr_scope_name_partsr*zGraphBuilder._scope_name_partscC"|}|rd|d|S|S)zPrepend the current hierarchical context prefix to the given name. Uses ``.`` as separator, appropriate for parameter and initializer names. rWr,joinrr;partsrrrrsz&GraphBuilder._qualify_initializer_namecCs,|}|rdd|d|Sd|S)zQualify a value name with the current scope using ``.`` separator. The name is prefixed with ``v_`` to distinguish values from parameters. v_rWr.r0rrrrs z GraphBuilder._qualify_value_namecCr-)zAQualify a node name with the current scope using ``/`` separator.rr.r0rrrrszGraphBuilder._qualify_node_namecCsBg}|jD]\}}|s |r||r|d|n|qd|S)zBuild the namespace string for a node. Each scope entry is formatted as ``name: class_name`` joined by ``/``. z: r)rxrHr/)rr1r;r+rrrrs  zGraphBuilder._build_namespace)r'r(rorsr r))r4)rrr:rr r)r r)r rsr rw)r r(r rr)rOrr;rrr%r r_)NN)r;rrrr`rr rr@rrrr r_)rr_r;rr r))rrrrr r_)rrrrr r)r)r9rrrr rq)rrrrr:rr r)rrr7rrrr r)rrr7rr re)rrr8rr r)rJrr r)) rprr7rer9rqr;rr r()rNr4) rrr:rr9rrrr7rrr)rr rr )rr rrrr)r#rr$rr r))r r))r r&)r;rr rr r)$__name__ __module__ __qualname____doc__rrpropertyryrorr'rrrrrrrrrrrrrnrrr"rrrrr,rrrrrrrrrwsp       % 0    8  7 ,3 ?     rwc@seZdZdZ d2d3d d Zed4ddZed5ddZed6ddZd7ddZ d8ddZ d9d:d#d$Z ed;d&d'Z dd(drzbDynamic op dispatcher that translates attribute access into ONNX node creation via a GraphBuilder.rNbuilderrwrrr:rr r)cCs||_||_||_dSr)_builder_domain_version)rr;rr:rrrrs zOpBuilder.__init__cCrr)r<rrrrr;rzOpBuilder.buildercCrr)r=rrrrrrzOpBuilder.domaincCrr)r>rrrrr: rzOpBuilder.versionrr7 Sequence[Any]rrcCs@|d|j}|d|j}|dd}|jj||||||dS)Nr=r>rr4)rr:r9)rGr=r>r<r)rrr7rrr:r9rrr_call_op s   zOpBuilder._call_oprcsfddS)Ncs||Sr)r@)rrrrrrsz'OpBuilder.__getattr__..r)rrrrAr __getattr__zOpBuilder.__getattr__rOrr;rr_cCs|j||Sr)r<r)rrOr;rrrrrDzOpBuilder.initializerrcCrr)r<rrrrrrrzOpBuilder.functionsrrSequence[str] | int | NonecOs|jj|g|Rd|i|S)aCall a function as a single function node. Args: function: The function to call (ir.Function or onnxscript.OnnxFunction). *args: Positional arguments to pass to the function. _outputs: Optional sequence of output names, or an integer specifying the number of outputs. **kwargs: Keyword arguments to pass to the function. Returns: The output value(s) from the function call. r)r<r)rrrrrrrrrszOpBuilder.callrrrcOs |jj|g|R||d|S)a<Inline a function body into the current graph. Args: function: The function to call (ir.Function or onnxscript.OnnxFunction). *args: Positional arguments to pass to the function. _outputs: Optional sequence of output names. If provided, must match the number of function outputs. _prefix: Optional prefix for module scoping (e.g., "layers.0"). **kwargs: Keyword arguments to pass to the function. Returns: The output value(s) from the inlined function body. r)r<r")rrrrrrrrrr"3szOpBuilder.call_inline)rN)r;rwrrr:rr r)r3r5)r r)rrr7r?rr)rrr rr)rOrr;rr r_r4)rrE)rrrr)r6r7r8r9rr:r;rr:r@rCrrrr"rrrrrs(        r)r r r r)rrr r)r)rrrrrrr r)r'r(r r))rSrTr rUr)r;rr]r^r r_)r7rer rf)rprr7rer9rqr?rrr;rrorsr r()rprr7rerrr;rr8rr?rrr r).r9 __future__rtypingrrrrrronnx_irrBonnxscript._internal._inference _internal _inferenceronnxscript.optimizerronnxscript._internalrr rbTensorProtocolrr$r%rrDataTypeINT64FLOATr __annotations__rrr&rRrXrTr\rdrmrrrwrrrrrsZ    9   /b`V