classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/qmod/qmod_parameter.py

@@ -1,14 +1,4 @@
-import sys
-from typing import (  # type: ignore[attr-defined]
-    TYPE_CHECKING,
-    Any,
-    Generic,
-    TypeVar,
-    Union,
-    _GenericAlias,
-)
-
-from typing_extensions import ParamSpec
+from typing import TYPE_CHECKING, Any, Union
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
@@ -19,65 +9,29 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
     Real,
 )
-from classiq.interface.generator.functions.type_name import TypeName
-
-from classiq import Struct, StructDeclaration
+from classiq.interface.generator.functions.type_name import Struct, TypeName
+
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.cparam import (  # noqa: F401
+    Array,
+    ArrayBase,
+    CArray,
+    CBool,
+    CInt,
+    CParam,
+    CParamScalar,
+    CReal,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
-_T = TypeVar("_T")
-
 if TYPE_CHECKING:
-    from classiq.qmod.qmod_variable import QNum
 
     SymbolicSuperclass = SymbolicExpr
 else:
     SymbolicSuperclass = Symbolic
 
 
-class CParam(SymbolicSuperclass):
-    def __init__(self, expr: str) -> None:
-        super().__init__(expr, False)
-
-
-class CInt(CParam):
-    pass
-
-
-class CReal(CParam):
-    pass
-
-
-class CBool(CParam):
-    pass
-
-
-_P = ParamSpec("_P")
-
-
-class ArrayBase(Generic[_P]):
-    # Support comma-separated generic args in older Python versions
-    if sys.version_info[0:2] < (3, 10):
-
-        def __class_getitem__(cls, args) -> _GenericAlias:
-            return _GenericAlias(cls, args)
-
-
-class CArray(CParam, ArrayBase[_P]):
-    if TYPE_CHECKING:
-
-        @property
-        def len(self) -> int: ...
-
-        def __getitem__(self, idx: Union[int, CInt, slice, "QNum"]) -> Any: ...
-
-
-class CParamScalar(CParam, SymbolicExpr):
-
-    def __hash__(self) -> int:
-        return hash(str(self))
-
-
 class CParamList(CParam):
     def __init__(
         self,
@@ -133,7 +87,7 @@ class CParamStruct(CParam):
         struct_name: str,
         field_name: str,
     ) -> CParam:
-        struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
+        struct_decl = BUILTIN_STRUCT_DECLARATIONS.get(
             struct_name, qmodule.type_decls.get(struct_name)
         )
         assert struct_decl is not None
@@ -162,9 +116,6 @@ def create_param(
         return CParamScalar(expr_str)
 
 
-Array = CArray
-
-
 def get_qmod_type(ctype: ClassicalType) -> type:
     if isinstance(ctype, Integer):
         return CInt

classiq/qmod/qmod_variable.py

@@ -57,24 +57,18 @@ from classiq.interface.model.quantum_type import (
 )
 from classiq.interface.source_reference import SourceReference
 
+from classiq.qmod.cparam import ArrayBase, CBool, CInt, CParamScalar
+from classiq.qmod.generative import (
+    generative_mode_context,
+    get_frontend_interpreter,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
-from classiq.qmod.qmod_parameter import ArrayBase, CBool, CInt, CParamScalar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 from classiq.qmod.utilities import get_source_ref, version_portable_get_args
 
-QVAR_PROPERTIES_ARE_SYMBOLIC = True
-
-
-@contextmanager
-def set_symbolic_qvar_properties(symbolic: bool) -> Iterator[None]:
-    global QVAR_PROPERTIES_ARE_SYMBOLIC
-    previous_symbolic = QVAR_PROPERTIES_ARE_SYMBOLIC
-    QVAR_PROPERTIES_ARE_SYMBOLIC = symbolic
-    yield
-    QVAR_PROPERTIES_ARE_SYMBOLIC = previous_symbolic
-
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
     return isinstance(type_hint, _AnnotatedAlias) and isinstance(
@@ -101,6 +95,10 @@ def _no_current_expandable() -> Iterator[None]:
         QCallable.CURRENT_EXPANDABLE = current_expandable
 
 
+def _evaluate_expression(expr: str) -> Any:
+    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value
+
+
 class QVar(Symbolic):
     def __init__(
         self,
@@ -171,14 +169,11 @@ class QVar(Symbolic):
 
     @property
     def size(self) -> Union[CParamScalar, int]:
-        if not QVAR_PROPERTIES_ARE_SYMBOLIC:
-            return self._evaluate_size()
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return _evaluate_expression(str(self.size))
         return CParamScalar(f"get_field({self}, 'size')")
 
-    @abc.abstractmethod
-    def _evaluate_size(self) -> int:
-        raise NotImplementedError
-
 
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
@@ -269,9 +264,6 @@ class QBit(QScalar):
     def get_qmod_type(self) -> QuantumType:
         return QuantumBit()
 
-    def _evaluate_size(self) -> int:
-        return 1
-
 
 _P = ParamSpec("_P")
 
@@ -358,25 +350,18 @@ class QNum(Generic[_P], QScalar):
             fraction_digits=self._fraction_digits,
         )
 
-    def _evaluate_size(self) -> int:
-        if TYPE_CHECKING:
-            assert self._size is not None
-        return self._size.to_int_value()
-
     @property
     def fraction_digits(self) -> Union[CParamScalar, int]:
-        if not QVAR_PROPERTIES_ARE_SYMBOLIC:
-            if TYPE_CHECKING:
-                assert self._fraction_digits is not None
-            return self._fraction_digits.to_int_value()
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return _evaluate_expression(str(self.fraction_digits))
         return CParamScalar(f"get_field({self}, 'fraction_digits')")
 
     @property
     def is_signed(self) -> Union[CParamScalar, bool]:
-        if not QVAR_PROPERTIES_ARE_SYMBOLIC:
-            if TYPE_CHECKING:
-                assert self._is_signed is not None
-            return self._is_signed.to_bool_value()
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return _evaluate_expression(str(self.is_signed))
         return CParamScalar(f"get_field({self}, 'is_signed')")
 
     # Support comma-separated generic args in older Python versions
@@ -479,17 +464,13 @@ class QArray(ArrayBase[_P], QVar):
 
         @property
         def len(self) -> Union[CParamScalar, int]:
-            if not QVAR_PROPERTIES_ARE_SYMBOLIC:
-                return self._length.to_int_value()
+            if is_generative_mode():
+                with generative_mode_context(False):
+                    return _evaluate_expression(str(self.len))
             if self._length is not None:
                 return CParamScalar(f"{self._length}")
             return CParamScalar(f"get_field({self}, 'len')")
 
-    def _evaluate_size(self) -> int:
-        if TYPE_CHECKING:
-            assert self._length is not None
-        return self._element_type.size_in_bits * self._length.to_int_value()
-
     @classmethod
     def _get_attributes(cls, type_hint: Any) -> Tuple[Type[QVar], Any]:
         type_args = version_portable_get_args(type_hint)
@@ -611,16 +592,17 @@ class QStruct(QVar):
         )
 
     def _add_qmod_qstruct(self, *, qmodule: ModelStateContainer) -> None:
+        from classiq.model_expansions.model_tables import SymbolTable
+
         if self._struct_name in qmodule.qstruct_decls:
             return
 
-        qmodule.qstruct_decls[self._struct_name] = QStructDeclaration(
+        struct_decl = QStructDeclaration(
             name=self._struct_name,
             fields={name: qvar.get_qmod_type() for name, qvar in self._fields.items()},
         )
-
-    def _evaluate_size(self) -> int:
-        return sum(var._evaluate_size() for var in self._fields.values())
+        qmodule.qstruct_decls[self._struct_name] = struct_decl
+        SymbolTable.qstruct_table[self._struct_name] = struct_decl
 
 
 def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:

classiq/qmod/quantum_callable.py

@@ -20,7 +20,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.source_reference import SourceReference
 
-from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.cparam import CInt
 from classiq.qmod.utilities import get_source_ref
 
 if TYPE_CHECKING:

classiq/qmod/quantum_expandable.py

@@ -46,6 +46,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.source_reference import SourceReference
 
+from classiq.qmod.generative import generative_mode_context, is_generative_mode
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import (
@@ -58,7 +59,6 @@ from classiq.qmod.qmod_parameter import (
 from classiq.qmod.qmod_variable import (
     QVar,
     create_qvar_for_port_decl,
-    set_symbolic_qvar_properties,
 )
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -99,7 +99,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def expand(self) -> None:
         if self not in QExpandable.STACK:
-            with self, set_symbolic_qvar_properties(True):
+            with self, generative_mode_context(False):
                 self._py_callable(*self._get_positional_args())
 
     def infer_rename_params(self) -> Optional[List[str]]:
@@ -111,7 +111,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         qtype: QuantumType,
         source_ref: Optional[SourceReference] = None,
     ) -> None:
-        self._body.append(
+        self.append_statement_to_body(
             VariableDeclarationStatement(
                 name=name, quantum_type=qtype, source_ref=source_ref
             )
@@ -161,6 +161,10 @@ class QLambdaFunction(QExpandable):
     def func_decl(self) -> AnonQuantumFunctionDeclaration:
         return self._decl
 
+    def expand(self) -> None:
+        if not is_generative_mode():
+            super().expand()
+
     def infer_rename_params(self) -> List[str]:
         return inspect.getfullargspec(self._py_callable).args
 
@@ -302,10 +306,12 @@ def prepare_arg(
             new_arg_decl = decl_without_type_attributes(arg_decl)
             val = QLambdaFunction(new_arg_decl, val)
             val.expand()
-            return QuantumLambdaFunction(
+            qlambda = QuantumLambdaFunction(
                 pos_rename_params=val.infer_rename_params(),
                 body=val.body,
             )
+            qlambda.set_py_callable(val._py_callable)
+            return qlambda
 
         if isinstance(val, QExpandable):
             val.expand()

classiq/qmod/quantum_function.py

@@ -9,50 +9,20 @@ from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.model.model import Model, SerializedModel
+from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
-    QuantumFunctionDeclaration,
 )
 
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
-from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray, CParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
-from classiq.qmod.utilities import mangle_keyword, unmangle_keyword
-from classiq.qmod.write_qmod import write_qmod
-
-
-def _lookup_qfunc(name: str) -> Optional[NamedParamsQuantumFunctionDeclaration]:
-    # FIXME: to be generalized to existing user-defined functions
-    return QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.get(name)
-
-
-def create_model(
-    entry_point: "QFunc",
-    constraints: Optional[Constraints] = None,
-    execution_preferences: Optional[ExecutionPreferences] = None,
-    preferences: Optional[Preferences] = None,
-    classical_execution_function: Optional[CFunc] = None,
-    out_file: Optional[str] = None,
-) -> SerializedModel:
-    if entry_point.func_decl.name != "main":
-        raise ClassiqError(
-            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
-        )
-    result = entry_point.create_model(
-        constraints, execution_preferences, preferences, classical_execution_function
-    ).get_model()
-
-    if out_file is not None:
-        write_qmod(result, out_file)
-
-    return result
+from classiq.qmod.utilities import mangle_keyword
 
 
 class QFunc(QExpandable):
@@ -142,10 +112,10 @@ class QFunc(QExpandable):
 
 
 class ExternalQFunc(QTerminalCallable):
+    _decl: NamedParamsQuantumFunctionDeclaration
+
     def __init__(self, py_callable: Callable) -> None:
-        decl = _lookup_qfunc(unmangle_keyword(py_callable.__name__))
-        if decl is None:
-            raise ClassiqError(f"Definition of {py_callable.__name__!r} not found")
+        decl = infer_func_decl(py_callable)
 
         py_callable.__annotations__.pop("return", None)
         if py_callable.__annotations__.keys() != {
@@ -157,13 +127,25 @@ class ExternalQFunc(QTerminalCallable):
         super().__init__(decl)
         functools.update_wrapper(self, py_callable)
 
+    @property
+    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        return self._decl
 
-class GenerativeQFunc(QTerminalCallable):
-    func_decl: NamedParamsQuantumFunctionDeclaration
 
-    def __init__(self, py_callable: Callable) -> None:
-        super().__init__(infer_func_decl(py_callable, QMODULE))
-        self.py_callable = py_callable
+class GenerativeQFunc(QExpandable):
+    def __init__(
+        self,
+        py_callable: Callable,
+        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+    ) -> None:
+        super().__init__(py_callable)
+        self._func_decl = func_decl
+
+    @property
+    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        if self._func_decl is None:
+            self._func_decl = infer_func_decl(self._py_callable, self._qmodule)
+        return self._func_decl
 
 
 ILLEGAL_PARAM_ERROR = "Unsupported type hint '{annotation}' for argument '{name}'."

classiq/qmod/semantics/error_manager.py

@@ -2,6 +2,7 @@ from contextlib import contextmanager
 from typing import Iterator, List, Optional, Type
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
 from classiq.interface.source_reference import SourceReferencedError
 
 
@@ -18,23 +19,34 @@ class ErrorManager:
         self._errors: List[SourceReferencedError] = []
         self._current_nodes_stack: List[ASTNode] = []
         self._call_stack: List[str] = []
+        self._ignore_errors: bool = False
+
+    @contextmanager
+    def ignore_errors_context(self) -> Iterator[None]:
+        previous = self._ignore_errors
+        self._ignore_errors = True
+        try:
+            yield
+        finally:
+            self._ignore_errors = previous
 
     @property
     def annotated_errors(self) -> List[str]:
         return [str(error) for error in self._errors]
 
     def add_error(self, error: str) -> None:
-        self._errors.append(
-            SourceReferencedError(
-                error=error,
-                source_ref=(
-                    self._current_nodes_stack[-1].source_ref
-                    if self._current_nodes_stack
-                    else None
-                ),
-                function=self.current_function,
+        if not self._ignore_errors:
+            self._errors.append(
+                SourceReferencedError(
+                    error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
+                    source_ref=(
+                        self._current_nodes_stack[-1].source_ref
+                        if self._current_nodes_stack
+                        else None
+                    ),
+                    function=self.current_function,
+                )
             )
-        )
 
     def get_errors(self) -> List[SourceReferencedError]:
         return self._errors

classiq/qmod/semantics/static_semantics_visitor.py

@@ -19,6 +19,9 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -45,7 +48,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq import AnonClassicalParameterDeclaration
+from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation import annotate_function_call_decl
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.func_call_validation import (
@@ -352,23 +355,18 @@ def resolve_function_calls(
     root: Any,
     quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
-    StaticSemanticsVisitor(
-        {
-            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
-            **quantum_function_dict,
-        },
-        [],
-    ).visit(root)
+    with ErrorManager().ignore_errors_context():
+        StaticSemanticsVisitor(
+            {**BUILTIN_FUNCTION_DECLARATIONS, **quantum_function_dict},
+            [],
+        ).visit(root)
 
 
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[Type[Exception]] = ClassiqSemanticError
 ) -> None:
     StaticSemanticsVisitor(
-        {
-            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
-            **model.function_dict,
-        },
+        {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},
         [const.name for const in model.constants],
     ).visit(model)
     if error_type is not None:

classiq/qmod/semantics/validation/types_validation.py

@@ -1,10 +1,13 @@
 from typing import Sequence, Union
 
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.quantum_type import QuantumBitvector
 
-from classiq import EnumDeclaration, StructDeclaration
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.error_manager import ErrorManager
 
@@ -12,12 +15,8 @@ from classiq.qmod.semantics.error_manager import ErrorManager
 def check_duplicate_types(
     types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]
 ) -> None:
-    known_types = {
-        type_.name for type_ in EnumDeclaration.BUILTIN_ENUM_DECLARATIONS.values()
-    }
-    known_types |= {
-        type_.name for type_ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.values()
-    }
+    known_types = {type_.name for type_ in BUILTIN_ENUM_DECLARATIONS.values()}
+    known_types |= {type_.name for type_ in BUILTIN_STRUCT_DECLARATIONS.values()}
     for type_ in types:
         if type_.name in known_types:
             with ErrorManager().node_context(type_):

classiq/qmod/utilities.py

@@ -44,10 +44,10 @@ def version_portable_get_args(py_type: type) -> tuple:
     else:
         type_args = get_args(py_type)[0]
     if not isinstance(type_args, tuple):
-        return type_args
+        return (type_args,)
     return tuple(
         (
-            version_portable_get_args(type_arg)
+            version_portable_get_args(type_arg)[0]
             if get_origin(type_arg) == Literal
             else type_arg
         )

classiq/qmod/write_qmod.py

@@ -17,6 +17,20 @@ def write_qmod(
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
 ) -> None:
+    """
+    Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
+    The native Qmod file may be uploaded to the Classiq IDE.
+
+    Args:
+        serialized_model: The serialized model to write as a native Qmod file and synthesis options file.
+        name: The name to save the file by.
+        directory: The directory to save the files in. If None, the current working directory is used.
+        decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
+
+    Returns:
+        None
+    """
+
     model = Model.parse_raw(serialized_model)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
         model

classiq/show.py

@@ -27,6 +27,16 @@ CANT_PARSE_QUANTUM_PROGRAM_MSG = (
 
 
 def show(quantum_program: SerializedQuantumProgram) -> None:
+    """
+    Displays the interactive representation of the quantum program in the Classiq IDE.
+
+    Args:
+        quantum_program:
+            The serialized quantum program to be displayed.
+
+    Links:
+        [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
+    """
     try:
         circuit = QuantumProgram.parse_raw(quantum_program)
     except pydantic.error_wrappers.ValidationError as exc: