classiq 0.83.0__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/interface/executor/user_budget.py

@@ -1,9 +1,9 @@
 import datetime
-from collections import defaultdict
 from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict, Field
+from tabulate import tabulate
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -15,6 +15,7 @@ class UserBudget(VersionedModel):
     available_budget: float
     used_budget: float
     last_allocation_date: datetime.datetime
+    budget_limit: Optional[float] = Field(default=None)
 
     model_config = ConfigDict(extra="ignore")
 
@@ -22,35 +23,27 @@ class UserBudget(VersionedModel):
 class UserBudgets(VersionedModel):
     budgets: list[UserBudget] = pydantic.Field(default=[])
 
-    def print_budgets(self) -> None:
-        def format_header() -> str:
-            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
-
-        def format_row(
-            provider: str, available: float, used: float, currency: str
-        ) -> str:
-            return f"| {provider:<20} | {available:<18.3f} | {used:<18.3f} | {currency:<8} |"
-
-        table_data: dict = defaultdict(
-            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
-        )
-
-        for budget in self.budgets:
-            provider = budget.provider
-            table_data[provider]["available"] += budget.available_budget
-            table_data[provider]["used"] += budget.used_budget
-            table_data[provider]["currency"] = budget.currency_code
-
-        line = "=" * 77
-        print(line)  # noqa: T201
-        print(format_header())  # noqa: T201
-        print(line)  # noqa: T201
-
-        for provider, values in table_data.items():
-            print(  # noqa: T201
-                format_row(
-                    provider, values["available"], values["used"], values["currency"]
-                )
-            )
-
-        print(line)  # noqa: T201
+    def __str__(self) -> str:
+        rows = [
+            [
+                budget.provider,
+                f"{budget.used_budget:.3f}",
+                f"{budget.available_budget:.3f}",
+                (
+                    f"{budget.budget_limit:.3f}"
+                    if budget.budget_limit is not None
+                    else "NOT SET"
+                ),
+                budget.currency_code,
+            ]
+            for budget in self.budgets
+        ]
+
+        headers = [
+            "Provider",
+            "Used Budget",
+            "Remaining Budget",
+            "Budget Limit",
+            "Currency",
+        ]
+        return tabulate(rows, headers=headers, tablefmt="grid")

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -23,7 +23,6 @@ CLASSIQ_EXPR_FUNCTIONS = {
 SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
     *CLASSIQ_EXPR_FUNCTIONS,
-    "mod_inverse",
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -34,6 +33,11 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "LogicalXor",
     "RShift",
     "LShift",
+    "mod_inverse",
+    "min",
+    "Min",
+    "max",
+    "Max",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -21,12 +21,6 @@ def subscript_to_str(index: Any) -> str:
 
 
 class AnyClassicalValue(sympy.Symbol):
-
-    is_commutative = None
-    is_infinite = None
-    is_finite = None
-    is_extended_real = None
-
     def __getitem__(self, item: Any) -> "AnyClassicalValue":
         if isinstance(item, slice):
             return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")

classiq/interface/generator/functions/classical_type.py

@@ -98,39 +98,6 @@ class Bool(ClassicalType):
         return values_with_discriminator(values, "kind", "bool")
 
 
-class ClassicalList(ClassicalType):
-    kind: Literal["list"]
-    element_type: "ConcreteClassicalType"
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_kind(cls, values: Any) -> dict[str, Any]:
-        return values_with_discriminator(values, "kind", "list")
-
-    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        return ClassicalArrayProxy(
-            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
-        )
-
-    @property
-    def expressions(self) -> list[Expression]:
-        return self.element_type.expressions
-
-    @property
-    def is_purely_declarative(self) -> bool:
-        return super().is_purely_declarative and self.element_type.is_purely_declarative
-
-    @property
-    def is_purely_generative(self) -> bool:
-        return super().is_purely_generative and self.element_type.is_purely_generative
-
-    def get_raw_type(self) -> "ConcreteClassicalType":
-        raw_type = ClassicalArray(element_type=self.element_type.get_raw_type())
-        if self._is_generative:
-            raw_type.set_generative()
-        return raw_type
-
-
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
@@ -146,8 +113,8 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: Optional[int] = None
-    length: Optional[Expression] = pydantic.Field(exclude=True, default=None)
+    size: Optional[int] = pydantic.Field(exclude=True, default=None)
+    length: Optional[Expression] = None
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/generator/functions/concrete_types.py

@@ -5,7 +5,6 @@ from pydantic import Field
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Estimation,
     Histogram,
@@ -29,7 +28,6 @@ ConcreteClassicalType = Annotated[
         Integer,
         Real,
         Bool,
-        ClassicalList,
         StructMetaType,
         TypeName,
         ClassicalArray,
@@ -41,7 +39,6 @@ ConcreteClassicalType = Annotated[
     ],
     Field(discriminator="kind"),
 ]
-ClassicalList.model_rebuild()
 ClassicalArray.model_rebuild()
 ClassicalTuple.model_rebuild()
 

classiq/interface/generator/functions/type_modifier.py

@@ -2,25 +2,6 @@ from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
-class TypeQualifier(StrEnum):
-    Const = "const"
-    QFree = "qfree"
-    Quantum = "quantum"
-    Inferred = "inferred"
-
-    def to_modifier(self) -> "TypeModifier":
-        if self is TypeQualifier.Const:
-            return TypeModifier.Const
-        elif self is TypeQualifier.QFree:
-            return TypeModifier.Permutable
-        elif self is TypeQualifier.Quantum:
-            return TypeModifier.Mutable
-        elif self is TypeQualifier.Inferred:
-            return TypeModifier.Inferred
-        else:
-            raise ClassiqInternalExpansionError(f"Unexpected type qualifier: {self}")
-
-
 class TypeModifier(StrEnum):
     Const = "const"
     Permutable = "permutable"

classiq/interface/generator/generated_circuit_data.py

@@ -28,8 +28,6 @@ from classiq.interface.model.statement_block import (
 )
 
 from classiq.model_expansions.capturing.mangling_utils import (
-    demangle_capture_name,
-    demangle_name,
     is_captured_var_name,
 )
 
@@ -85,12 +83,6 @@ class GeneratedRegister(pydantic.BaseModel):
     def is_captured(self) -> bool:
         return is_captured_var_name(self.name)
 
-    @staticmethod
-    def demangle_name(name: str) -> str:
-        if is_captured_var_name(name):
-            name = demangle_capture_name(name)
-        return demangle_name(name)
-
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str

classiq/interface/generator/types/compilation_metadata.py

@@ -6,9 +6,6 @@ class CompilationMetadata(BaseModel):
     occurrences_number: NonNegativeInt = Field(default=1)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
     unchecked: list[str] = Field(default_factory=list)
-    atomic_qualifiers: list[str] = Field(
-        default_factory=list, exclude=True
-    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671
 
     @property
     def occupation_number(self) -> NonNegativeInt:

classiq/interface/ide/visual_model.py

@@ -110,7 +110,9 @@ class Operation(pydantic.BaseModel):
     name: str
     qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
-    children: list["Operation"]
+    children: list["Operation"] = pydantic.Field(default_factory=list)
+    # children_ids is optional in order to support backwards compatibility.
+    children_ids: list[int] = pydantic.Field(default_factory=list)
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
@@ -129,5 +131,7 @@ class Operation(pydantic.BaseModel):
 
 
 class ProgramVisualModel(VersionedModel):
-    main_operation: Operation
+    main_operation: Operation = pydantic.Field(default=None)
+    id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
+    main_operation_id: int = pydantic.Field(default=None)
     program_data: ProgramData

classiq/interface/model/model.py

@@ -185,11 +185,16 @@ class Model(VersionedModel, ASTNode):
         return constants
 
     def dump_no_metadata(self) -> dict[str, Any]:
-        return self.model_dump(
-            exclude={
-                "constraints",
-                "execution_preferences",
-                "preferences",
-                "functions_compilation_metadata",
-            },
+        compilation_metadata_with_unchecked = {
+            name: CompilationMetadata(unchecked=comp_metadata.unchecked)
+            for name, comp_metadata in self.functions_compilation_metadata.items()
+            if len(comp_metadata.unchecked) > 0
+        }
+        model = self.model_copy(
+            update={
+                "functions_compilation_metadata": compilation_metadata_with_unchecked,
+            }
+        )
+        return model.model_dump(
+            exclude={"constraints", "execution_preferences", "preferences"},
         )

classiq/interface/model/port_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -10,7 +10,6 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.functions.type_modifier import (
     TypeModifier,
-    TypeQualifier,
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
@@ -19,35 +18,14 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    type_qualifier: Optional[TypeQualifier] = pydantic.Field(
-        default=None, exclude=True
-    )  # TODO remove after BWC breaking release https://classiq.atlassian.net/browse/CLS-2777
     kind: Literal["PortDeclaration"]
-    type_modifier: TypeModifier = pydantic.Field(default=None)
+    type_modifier: TypeModifier
 
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "PortDeclaration")
 
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_type_modifier(cls, values: Any) -> dict[str, Any]:
-        if values.get("type_modifier") is None:
-            type_qualifier = values.get("type_qualifier")
-            if type_qualifier is not None:
-                if isinstance(type_qualifier, TypeQualifier):
-                    values["type_modifier"] = type_qualifier.to_modifier()
-                elif isinstance(type_qualifier, str):
-                    values["type_modifier"] = TypeQualifier(
-                        type_qualifier
-                    ).to_modifier()
-                else:
-                    raise pydantic.ValidationError("Missing a type modifier")
-            else:
-                raise pydantic.ValidationError("Missing a type modifier")
-        return values
-
     @pydantic.field_validator("direction", mode="before")
     @classmethod
     def _direction_validator(

classiq/{qmod/native → interface/pretty_print}/expression_to_qmod.py

@@ -6,7 +6,7 @@ from typing import Callable, Optional
 
 import numpy as np
 
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {
@@ -40,6 +40,10 @@ COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
 LIST_FORMAT_CHAR_LIMIT = 20
 
 
+class PrettyPrinterError(AssertionError):
+    pass
+
+
 @dataclass
 class ASTToQMODCode:
     level: int
@@ -59,10 +63,13 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
             if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise AssertionError("Error parsing enum attribute access")
+                raise PrettyPrinterError("Error parsing enum attribute access")
             if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
-                raise AssertionError("Error parsing enum attribute access")
-            return f"{node.value.id!s}::{node.attr!s}"
+                raise PrettyPrinterError("Error parsing enum attribute access")
+            # FIXME: identify enum member accesses by type name (CLS-2858)
+            if len(node.value.id) > 0 and node.value.id[0].isupper():
+                return f"{node.value.id!s}::{node.attr!s}"
+            return f"{node.value.id!s}.{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
@@ -91,7 +98,7 @@ class ASTToQMODCode:
             )
         elif isinstance(node, ast.Compare):
             if len(node.ops) != 1 or len(node.comparators) != 1:
-                raise AssertionError("Error parsing comparison expression.")
+                raise PrettyPrinterError("Error parsing comparison expression.")
             return "({} {} {})".format(
                 self.ast_to_code(node.left),
                 COMPARE_OPS[type(node.ops[0])],
@@ -108,20 +115,20 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Slice):
             # A QMOD expression does not support slice step
             if node.lower is None or node.upper is None or node.step is not None:
-                raise AssertionError("Error parsing slice expression.")
+                raise PrettyPrinterError("Error parsing slice expression.")
             return f"{self.ast_to_code(node.lower)}:{self.ast_to_code(node.upper)}"
         elif isinstance(node, ast.Call):
             func = self.ast_to_code(node.func)
             if func == "get_field":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 field = str(self.ast_to_code(node.args[1])).replace("'", "")
                 if not IDENTIFIER.match(field):
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 return f"{self.ast_to_code(node.args[0])}.{field}"
             elif func == "struct_literal":
                 if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
-                    raise AssertionError("Error parsing struct literal.")
+                    raise PrettyPrinterError("Error parsing struct literal.")
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
@@ -133,7 +140,7 @@ class ASTToQMODCode:
                 return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
             elif func == "do_subscript":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing array access.")
+                    raise PrettyPrinterError("Error parsing array access.")
                 return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
             else:
                 return "{}({})".format(
@@ -142,7 +149,7 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Expr):
             return self._cleaned_ast_to_code(node.value)
         else:
-            raise AssertionError("Error parsing expression: unsupported AST node.")
+            raise PrettyPrinterError("Error parsing expression: unsupported AST node.")
 
     def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (

classiq/interface/server/routes.py

@@ -91,3 +91,7 @@ IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
 
 USER_BUDGETS_SUFFIX = "/all"
 USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX
+USER_BUDGET_SET_LIMIT_SUFFIX = "/set_limit"
+USER_BUDGET_SET_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_SET_LIMIT_SUFFIX
+USER_BUDGET_CLEAR_LIMIT_SUFFIX = "/clear_limit"
+USER_BUDGET_CLEAR_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_CLEAR_LIMIT_SUFFIX

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -39,7 +39,6 @@ from classiq.interface.generator.functions.classical_function_declaration import
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     OpaqueHandle,
@@ -91,7 +90,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, (Enum, int)):
             return val
 
-    elif isinstance(qmod_type, (ClassicalArray, ClassicalList)):
+    elif isinstance(qmod_type, ClassicalArray):
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
 
@@ -145,9 +144,9 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             field_name: python_val_to_qmod(val[field_name], field_type)
             for field_name, field_type in struct_decl.variables.items()
         }
-        return QmodStructInstance(struct_decl.model_copy(), qmod_dict)
+        return QmodStructInstance(struct_decl.model_copy(deep=True), qmod_dict)
 
-    if isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+    if isinstance(qmod_type, ClassicalArray):
         if not isinstance(val, list):
             raise ClassiqInternalExpansionError("Bad value for list")
         return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
@@ -182,7 +181,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        QMODULE.type_decls[struct_type_symbol.name].model_copy(),
+        QMODULE.type_decls[struct_type_symbol.name].model_copy(deep=True),
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -330,6 +329,40 @@ def mod_inverse(a: Any, b: Any) -> Any:
     return sympy.mod_inverse(a, b)
 
 
+def min_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Min(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Min({', '.join(map(str, vals))})")
+
+
+min_wrapper.__name__ = "min"
+
+
+def Min_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return min_wrapper(*vals)
+
+
+Min_wrapper.__name__ = "Min"
+
+
+def max_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Max(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Max({', '.join(map(str, vals))})")
+
+
+max_wrapper.__name__ = "max"
+
+
+def Max_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return max_wrapper(*vals)
+
+
+Max_wrapper.__name__ = "Max"
+
+
 CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
     do_sum,
@@ -347,6 +380,10 @@ CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     RShift,
     LShift,
     mod_inverse,
+    min_wrapper,
+    Min_wrapper,
+    max_wrapper,
+    Max_wrapper,
 ]
 
 

classiq/model_expansions/interpreters/base_interpreter.py

@@ -39,14 +39,14 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
+from classiq.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
-from classiq.model_expansions.evaluators.classical_expression import (
-    evaluate_classical_expression,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,

classiq/model_expansions/quantum_operations/allocate.py

@@ -12,7 +12,7 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -24,7 +24,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,

classiq/model_expansions/quantum_operations/bind.py

@@ -8,10 +8,10 @@ from classiq.interface.exceptions import (
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.quantum_type import QuantumNumeric
 
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
 )
-from classiq.model_expansions.evaluators.quantum_type_utils import (
+from classiq.evaluators.quantum_type_utils import (
     set_size,
     validate_bind_targets,
 )