classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/qmod/expression_query.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Tuple
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
@@ -9,13 +9,29 @@ from classiq.qmod.symbolic_type import SymbolicTypes
 
 
 def get_expression_numeric_attributes(
-    vars: List[QNum],
+    vars: list[QNum],
     expr: SymbolicTypes,
     machine_precision: int = MAXIMAL_MACHINE_PRECISION,
-) -> Tuple[int, bool, int]:
+) -> tuple[int, bool, int]:
+    """
+    Computes and returns the numeric attributes of a given symbolic expression.
+
+    Args:
+        vars: A list of `QNum` variables used in the symbolic expression.
+        expr: The symbolic expression for which numeric attributes are to be computed.
+        machine_precision: The precision level of the machine for the computation. Defaults to MAXIMAL_MACHINE_PRECISION = 20.
+
+    Returns:
+        Tuple[int, bool, int]:
+            A tuple containing the following numeric attributes:
+            - The size in bits (int) required to represent the result.
+            - A boolean indicating whether the result is signed (bool).
+            - The number of fraction digits (int) in the result.
+
+    """
     res_type = compute_arithmetic_result_type(
         expr_str=str(expr),
-        var_types={var._name: var.get_qmod_type() for var in vars},
+        var_types={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},
         machine_precision=machine_precision,
     )
     if TYPE_CHECKING:

classiq/qmod/generative.py

@@ -0,0 +1,42 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, Optional
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.expressions.expression import Expression
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+_GENERATIVE_MODE: bool = False
+_FRONTEND_INTERPRETER: Optional["BaseInterpreter"] = None
+
+
+def is_generative_mode() -> bool:
+    return _GENERATIVE_MODE
+
+
+@contextmanager
+def generative_mode_context(generative: bool) -> Iterator[None]:
+    global _GENERATIVE_MODE
+    previous = _GENERATIVE_MODE
+    _GENERATIVE_MODE = generative
+    try:
+        yield
+    finally:
+        _GENERATIVE_MODE = previous
+
+
+def set_frontend_interpreter(interpreter: "BaseInterpreter") -> None:
+    global _FRONTEND_INTERPRETER
+    _FRONTEND_INTERPRETER = interpreter
+
+
+def get_frontend_interpreter() -> "BaseInterpreter":
+    if _FRONTEND_INTERPRETER is None:
+        raise ClassiqError("Interpreter was not set")
+    return _FRONTEND_INTERPRETER
+
+
+def interpret_expression(expr: str) -> Any:
+    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value

classiq/qmod/model_state_container.py

@@ -1,15 +1,27 @@
-from typing import Dict
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.constant import Constant
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
+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.native_function_definition import (
+    NativeFunctionDefinition,
+)
 
-from classiq import StructDeclaration
+if TYPE_CHECKING:
+    from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class ModelStateContainer:
-    type_decls: Dict[str, StructDeclaration]
-    native_defs: Dict[str, NativeFunctionDefinition]
-    constants: Dict[str, Constant]
+    enum_decls: dict[str, EnumDeclaration]
+    type_decls: dict[str, StructDeclaration]
+    qstruct_decls: dict[str, QStructDeclaration]
+    native_defs: dict[str, NativeFunctionDefinition]
+    constants: dict[str, Constant]
+    functions_compilation_metadata: dict[str, CompilationMetadata]
+    generative_functions: dict[str, "GenerativeQFunc"]
+    function_dependencies: dict[str, list[str]]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/__init__.py

@@ -0,0 +1,7 @@
+from .pretty_printer import DSLPrettyPrinter
+
+__all__ = ["DSLPrettyPrinter"]
+
+
+def __dir__() -> list[str]:
+    return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,14 +1,15 @@
 import ast
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable, Optional
 
 import numpy as np
 
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
-BINARY_OPS: Mapping[Type[ast.operator], str] = {
+BINARY_OPS: Mapping[type[ast.operator], str] = {
     ast.Add: "+",
     ast.Sub: "-",
     ast.Mult: "*",
@@ -21,14 +22,14 @@ BINARY_OPS: Mapping[Type[ast.operator], str] = {
     ast.LShift: "<<",
     ast.RShift: ">>",
 }
-BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
-UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+BOOL_OPS: Mapping[type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[type[ast.unaryop], str] = {
     ast.UAdd: "+",
     ast.USub: "-",
     ast.Invert: "~",
     ast.Not: "not",
 }
-COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -42,7 +43,7 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode:
     level: int
-    decimal_precision: int
+    decimal_precision: Optional[int]
     indent_seq: str = "  "
 
     @property
@@ -65,6 +66,8 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
+            if self.decimal_precision is None:
+                return str(node.n)
             return str(np.round(node.n, self.decimal_precision))
         elif isinstance(node, ast.Str):
             return repr(node.s)
@@ -122,7 +125,7 @@ class ASTToQMODCode:
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
-                        f"{keyword.arg} = {self._cleaned_ast_to_code(keyword.value)}"
+                        f"{keyword.arg}={self._cleaned_ast_to_code(keyword.value)}"
                         for keyword in keywords
                         if keyword.arg is not None
                     ]
@@ -137,7 +140,7 @@ class ASTToQMODCode:
         else:
             raise AssertionError("Error parsing expression: unsupported AST node.")
 
-    def indent_items(self, items: Callable[[], List[str]]) -> str:
+    def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (
             len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
         )
@@ -163,8 +166,8 @@ class ASTToQMODCode:
 def _remove_redundant_parentheses(expr: str) -> str:
     if not (expr.startswith("(") and expr.endswith(")")):
         return expr
-    parentheses_map: Dict[int, int] = dict()
-    stack: List[int] = []
+    parentheses_map: dict[int, int] = dict()
+    stack: list[int] = []
     for index, char in enumerate(expr):
         if char == "(":
             stack.append(index)
@@ -182,7 +185,9 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 
 def transform_expression(
-    expr: str, level: int = 0, decimal_precision: int = DEFAULT_DECIMAL_PRECISION
+    expr: str,
+    level: int = 0,
+    decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
 ) -> str:
     return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
         ast.parse(expr)