classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/combinatorial_optimization/examples/mis.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mis(graph: nx.Graph) -> pyo.ConcreteModel:
@@ -7,7 +8,9 @@ def mis(graph: nx.Graph) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
 
     @model.Constraint(graph.edges)
-    def independent_rule(model, node1, node2):
+    def independent_rule(
+        model: pyo.ConcreteModel, node1: int, node2: int
+    ) -> pyo_expr.ExpressionBase:
         return model.x[node1] + model.x[node2] <= 1
 
     model.cost = pyo.Objective(expr=sum(model.x.values()), sense=pyo.maximize)

classiq/interface/combinatorial_optimization/examples/mvc.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def mvc(graph: nx.Graph, k: int) -> pyo.ConcreteModel:
@@ -7,7 +8,7 @@ def mvc(graph: nx.Graph, k: int) -> pyo.ConcreteModel:
     model.x = pyo.Var(graph.nodes, domain=pyo.Binary)
     model.amount_constraint = pyo.Constraint(expr=sum(model.x.values()) == k)
 
-    def obj_expression(model):
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.ExpressionBase:
         # number of edges not covered
         return sum((1 - model.x[i]) * (1 - model.x[j]) for i, j in graph.edges)
 

classiq/interface/combinatorial_optimization/examples/portfolio_variations.py

@@ -1,9 +1,9 @@
-from typing import List, Tuple, Union
+from typing import Union
 
 import numpy as np
 import pyomo.core as pyo
 
-BoundsList = List[Union[Tuple[int, int], int]]
+BoundsList = list[Union[tuple[int, int], int]]
 
 
 def portfolio_optimization_binary(

classiq/interface/combinatorial_optimization/examples/set_cover.py

@@ -1,10 +1,10 @@
 import itertools
-from typing import List
 
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
-def set_cover(sub_sets: List[List[int]]) -> pyo.ConcreteModel:
+def set_cover(sub_sets: list[list[int]]) -> pyo.ConcreteModel:
     entire_set = set(itertools.chain(*sub_sets))
     n = max(entire_set)
     num_sets = len(sub_sets)
@@ -16,7 +16,7 @@ def set_cover(sub_sets: List[List[int]]) -> pyo.ConcreteModel:
     model.x = pyo.Var(range(num_sets), domain=pyo.Binary)
 
     @model.Constraint(entire_set)
-    def independent_rule(model, num):
+    def independent_rule(model: pyo.ConcreteModel, num: int) -> pyo_expr.ExpressionBase:
         return sum(model.x[idx] for idx in range(num_sets) if num in sub_sets[idx]) >= 1
 
     model.cost = pyo.Objective(expr=sum(model.x.values()), sense=pyo.minimize)

classiq/interface/combinatorial_optimization/examples/tsp.py

@@ -2,6 +2,7 @@ import itertools
 
 import numpy as np
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 
 def tsp(distance_matrix: np.ndarray) -> pyo.ConcreteModel:
@@ -22,16 +23,16 @@ def tsp(distance_matrix: np.ndarray) -> pyo.ConcreteModel:
     @model.Constraint(points)
     def each_step_visits_one_point_rule(
         model: pyo.ConcreteModel, ii: int
-    ) -> pyo.ExpressionBase:
+    ) -> pyo_expr.ExpressionBase:
         return sum(model.x[ii, jj] for jj in range(num_points)) == 1
 
     @model.Constraint(points)
     def each_point_visited_once_rule(
         model: pyo.ConcreteModel, jj: int
-    ) -> pyo.ExpressionBase:
+    ) -> pyo_expr.ExpressionBase:
         return sum(model.x[ii, jj] for ii in range(num_points)) == 1
 
-    def is_travel_between_2_points(point1: int, point2: int) -> pyo.ExpressionBase:
+    def is_travel_between_2_points(point1: int, point2: int) -> pyo_expr.ExpressionBase:
         return sum(model.x[point1, kk] * model.x[point2, kk + 1] for kk in points[:-1])
 
     model.cost = pyo.Objective(

classiq/interface/combinatorial_optimization/examples/tsp_digraph.py

@@ -21,11 +21,15 @@ def tsp_digraph(
     )  # x[i, j] = 1 indicates that point i is visited at step j
 
     @model.Constraint(points)
-    def each_step_visits_one_point_rule(model, ii):
+    def each_step_visits_one_point_rule(
+        model: pyo.ConcreteModel, ii: int
+    ) -> pyo.ExpressionBase:
         return sum(model.x[ii, jj] for jj in steps) == 1
 
     @model.Constraint(steps)
-    def each_point_visited_once_rule(model, jj):
+    def each_point_visited_once_rule(
+        model: pyo.ConcreteModel, jj: int
+    ) -> pyo.ExpressionBase:
         return sum(model.x[ii, jj] for ii in points) == 1
 
     def is_travel_between_2_points(point1: int, point2: int) -> pyo.ExpressionBase:

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -1,10 +1,10 @@
-from typing import List
-
 import more_itertools
 import numpy as np
 import pydantic
 from pydantic import BaseModel
 
+from classiq.interface.exceptions import ClassiqValueError
+
 _TOLERANCE_DECIMALS = 6
 
 
@@ -22,7 +22,7 @@ class MhtQaoaInput(BaseModel):
     reps: pydantic.PositiveInt = pydantic.Field(
         default=3, description="Number of QAOA layers."
     )
-    plot_list: List[PlotData] = pydantic.Field(
+    plot_list: list[PlotData] = pydantic.Field(
         description="The list of (x,y,t) plots of the MHT problem."
     )
     misdetection_maximum_time_steps: pydantic.NonNegativeInt = pydantic.Field(
@@ -51,8 +51,11 @@ class MhtQaoaInput(BaseModel):
     def is_valid_cost(self, cost: float) -> bool:
         return True
 
-    @pydantic.validator("plot_list")
-    def round_plot_list_times_and_validate(cls, plot_list):
+    @pydantic.field_validator("plot_list")
+    @classmethod
+    def round_plot_list_times_and_validate(
+        cls, plot_list: list[PlotData]
+    ) -> list[PlotData]:
         MhtQaoaInput._check_all_ids_are_distinct(plot_list)
         MhtQaoaInput._round_to_tolerance_decimals(plot_list)
 
@@ -63,16 +66,18 @@ class MhtQaoaInput(BaseModel):
         }
 
         if len(time_diff_set) != 1:
-            raise ValueError("The time difference between each time stamp is not equal")
+            raise ClassiqValueError(
+                "The time difference between each time stamp is not equal"
+            )
 
         return plot_list
 
     @staticmethod
-    def _round_to_tolerance_decimals(plot_list: List[PlotData]) -> None:
+    def _round_to_tolerance_decimals(plot_list: list[PlotData]) -> None:
         for plot in plot_list:
             plot.t = np.round(plot.t, decimals=_TOLERANCE_DECIMALS)
 
     @staticmethod
-    def _check_all_ids_are_distinct(plot_list: List[PlotData]) -> None:
+    def _check_all_ids_are_distinct(plot_list: list[PlotData]) -> None:
         if not more_itertools.all_unique(plot.plot_id for plot in plot_list):
-            raise ValueError("Plot IDs should be unique.")
+            raise ClassiqValueError("Plot IDs should be unique.")

classiq/interface/combinatorial_optimization/optimization_problem.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 from pydantic import BaseModel
@@ -14,4 +14,4 @@ class MaxCutProblem(BaseModel):
         default_factory=CombinatorialOptimizer,
         description="preferences for the VQE execution",
     )
-    serialized_graph: Dict[str, Any]
+    serialized_graph: dict[str, Any]

classiq/interface/combinatorial_optimization/result.py

@@ -1,10 +1,8 @@
-from typing import List
-
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
 class AnglesResult(VersionedModel):
-    initial_point: List[float]
+    initial_point: list[float]
 
 
 class PyomoObjectResult(VersionedModel):

classiq/interface/combinatorial_optimization/solver_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class QSolver(StrEnum):

classiq/interface/debug_info/debug_info.py

@@ -0,0 +1,86 @@
+import json
+from collections.abc import Mapping
+from typing import Any, Optional, Union
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.generated_circuit_data import (
+    FunctionDebugInfoInterface,
+    OperationLevel,
+)
+
+ParameterValue = Union[float, int, str, None]
+
+
+class StatementType(StrEnum):
+    CONTROL = "control"
+    POWER = "power"
+    INVERT = "invert"
+    WITHIN_APPLY = "within_apply"
+    ASSIGNMENT = "assignment"
+    REPEAT = "repeat"
+
+
+class FunctionDebugInfo(BaseModel):
+    name: str
+    # Parameters describe classical parameters passed to function
+    parameters: dict[str, str]
+    level: OperationLevel
+    statement_type: Union[StatementType, None] = None
+    is_allocate_or_free: bool = Field(default=False)
+    is_inverse: bool = Field(default=False)
+    port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
+
+    @staticmethod
+    def param_controller(value: Any) -> str:
+        try:
+            return json.dumps(value)
+        except TypeError:
+            return repr(value)
+
+    def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, new_key in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                new_port_to_passed_variable_map[new_key] = (
+                    new_port_to_passed_variable_map.pop(old_key)
+                )
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
+    def update_map_from_inout_port_mapping(
+        self, port_mapping: Mapping[str, tuple[str, str]]
+    ) -> None:
+        new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
+        for old_key, (new_key1, new_key2) in port_mapping.items():
+            if old_key in new_port_to_passed_variable_map:
+                value = new_port_to_passed_variable_map.pop(old_key)
+                new_port_to_passed_variable_map[new_key1] = value
+                new_port_to_passed_variable_map[new_key2] = value
+        self.port_to_passed_variable_map = new_port_to_passed_variable_map
+
+
+class DebugInfoCollection(BaseModel):
+    # Pydantic only started supporting UUID as keys in Pydantic V2
+    # See https://github.com/pydantic/pydantic/issues/2096#issuecomment-814860206
+    # For now, we use strings as keys in the raw data and use UUID in the wrapper logic
+    data: dict[str, FunctionDebugInfo] = Field(default={})
+    blackbox_data: dict[str, FunctionDebugInfoInterface] = Field(default={})
+
+    def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
+        self.data[str(key)] = value
+
+    def get(self, key: UUID) -> Optional[FunctionDebugInfo]:
+        return self.data.get(str(key))
+
+    def __getitem__(self, key: UUID) -> FunctionDebugInfo:
+        return self.data[str(key)]
+
+    def __contains__(self, key: UUID) -> bool:
+        return str(key) in self.data
+
+    def get_blackbox_data(self, key: UUID) -> Optional[FunctionDebugInfoInterface]:
+        if (debug_info := self.get(key)) is None:
+            return None
+        return self.blackbox_data.get(debug_info.name)

classiq/interface/exceptions.py

@@ -0,0 +1,201 @@
+import logging
+from collections.abc import Iterable
+from typing import Optional
+
+_logger = logging.getLogger(__name__)
+
+CLASSIQ_SLACK_COMMUNITY_LINK = (
+    "\nIf you need further assistance, please reach out on our Community Slack channel "
+    "at: https://short.classiq.io/join-slack"
+)
+
+
+class ClassiqError(Exception):
+    def __init__(self, message: str) -> None:
+        self._raw_message = message
+        if CLASSIQ_SLACK_COMMUNITY_LINK not in message:
+            message = message + CLASSIQ_SLACK_COMMUNITY_LINK
+        super().__init__(message)
+
+    @property
+    def raw_message(self) -> str:
+        return self._raw_message
+
+
+class ClassiqExecutionError(ClassiqError):
+    pass
+
+
+class ClassiqMissingOutputFormatError(ClassiqError):
+    def __init__(self, missing_formats: list[str]) -> None:
+        msg = (
+            f"Cannot create program because output format is missing. "
+            f"Expected one of the following formats: {missing_formats}"
+        )
+        super().__init__(message=msg)
+
+
+class ClassiqCombinatorialOptimizationError(ClassiqError):
+    pass
+
+
+class ClassiqOracleError(ClassiqError):
+    pass
+
+
+class ClassiqAnalyzerError(ClassiqError):
+    pass
+
+
+class ClassiqAnalyzerVisualizationError(ClassiqError):
+    pass
+
+
+class ClassiqAPIError(ClassiqError):
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class ClassiqVersionError(ClassiqError):
+    pass
+
+
+class ClassiqValueError(ClassiqError, ValueError):
+    pass
+
+
+class ClassiqArithmeticError(ClassiqValueError):
+    pass
+
+
+class ClassiqIndexError(ClassiqError, IndexError):
+    pass
+
+
+class ClassiqWiringError(ClassiqValueError):
+    pass
+
+
+class ClassiqControlError(ClassiqError):
+    def __init__(self) -> None:
+        message = "Repeated control names, please rename the control states"
+        super().__init__(message=message)
+
+
+class ClassiqQRegError(ClassiqValueError):
+    pass
+
+
+class ClassiqQFuncError(ClassiqValueError):
+    pass
+
+
+class ClassiqQSVMError(ClassiqValueError):
+    pass
+
+
+class ClassiqQNNError(ClassiqValueError):
+    pass
+
+
+class ClassiqTorchError(ClassiqQNNError):
+    pass
+
+
+class ClassiqChemistryError(ClassiqError):
+    pass
+
+
+class ClassiqAuthenticationError(ClassiqError):
+    pass
+
+
+class ClassiqExpiredTokenError(ClassiqAuthenticationError):
+    pass
+
+
+class ClassiqFileNotFoundError(FileNotFoundError):
+    pass
+
+
+class ClassiqStateInitializationError(ClassiqError):
+    pass
+
+
+class ClassiqPasswordManagerSelectionError(ClassiqError):
+    pass
+
+
+class ClassiqMismatchIOsError(ClassiqError):
+    pass
+
+
+class ClassiqNotImplementedError(ClassiqError, NotImplementedError):
+    pass
+
+
+class ClassiqCombOptError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNoSolutionError(ClassiqError):
+
+    def __init__(self) -> None:
+        super().__init__("There is no valid solution for this optimization problem.")
+
+
+class ClassiqCombOptTrivialProblemError(ClassiqError):
+
+    def __init__(self, solution: list[int]) -> None:
+        super().__init__(
+            message=f"The problem doesn't have free decision variables. "
+            f"The trivial solution is {solution}."
+        )
+
+
+class ClassiqCombOptInvalidEncodingTypeError(ClassiqError):
+
+    def __init__(self, encoding_type: str, valid_types: Iterable[str]) -> None:
+        super().__init__(
+            f"Invalid variable encoding type {encoding_type}. "
+            f"The available encoding types are {list(valid_types)}"
+        )
+
+
+class ClassiqNonNumericCoefficientInPauliError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNotSupportedProblemError(ClassiqCombOptError):
+    pass
+
+
+class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
+
+    def __init__(self) -> None:
+        super().__init__("Invalid hamiltonian")
+
+
+class ClassiqSemanticError(ClassiqError):
+    pass
+
+
+class ClassiqDeprecationWarning(FutureWarning):
+    pass
+
+
+class ClassiqExpansionError(ClassiqError):
+    pass
+
+
+class ClassiqInternalError(ClassiqError):
+    def __init__(self, message: Optional[str] = None) -> None:
+        final_message = "Internal error occurred. Please contact Classiq support."
+        if message is not None:
+            final_message += f"\nError: {message}"
+        super().__init__(final_message)
+
+
+class ClassiqInternalExpansionError(ClassiqInternalError):
+    pass

classiq/interface/execution/iqcc.py

@@ -0,0 +1,19 @@
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class IQCCInitAuthData(VersionedModel):
+    auth_scope_id: str
+    auth_method_id: str
+
+
+class IQCCInitAuthResponse(VersionedModel):
+    auth_url: str
+    token_id: str
+
+
+class IQCCProbeAuthData(IQCCInitAuthData):
+    token_id: str
+
+
+class IQCCProbeAuthResponse(VersionedModel):
+    auth_token: str

classiq/interface/execution/jobs.py

@@ -1,28 +1,31 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, Field
 
+from classiq.interface.executor.execution_request import JobCost
 from classiq.interface.jobs import JobStatus
 
 
-class ExecutionJobDetailsV1(BaseModel, extra=Extra.ignore):
+class ExecutionJobDetailsV1(BaseModel, extra="ignore"):
     id: str
 
-    name: Optional[str]
+    name: Optional[str] = None
     start_time: datetime
-    end_time: Optional[datetime]
+    end_time: Optional[datetime] = None
 
-    provider: Optional[str]
-    backend_name: Optional[str]
+    provider: Optional[str] = None
+    backend_name: Optional[str] = None
 
     status: JobStatus
 
-    num_shots: Optional[int]
-    program_id: Optional[str]
+    num_shots: Optional[int] = None
+    program_id: Optional[str] = None
 
-    error: Optional[str]
+    error: Optional[str] = None
 
+    cost: Optional[JobCost] = Field(default=None)
 
-class ExecutionJobsQueryResultsV1(BaseModel, extra=Extra.ignore):
-    results: List[ExecutionJobDetailsV1]
+
+class ExecutionJobsQueryResultsV1(BaseModel, extra="ignore"):
+    results: list[ExecutionJobDetailsV1]

classiq/interface/execution/primitives.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.executor.quantum_code import Arguments
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
+
+
+class EstimateInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
+    hamiltonian: PauliOperator
+    parameters: list[Arguments]
+
+
+class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
+    sample: Optional[list[Arguments]] = Field(default=None)
+    estimate: Optional[EstimateInput] = Field(default=None)
+    random_seed: Optional[int] = Field(default=None)

classiq/interface/executor/constants.py

@@ -0,0 +1 @@
+DEFAULT_RESULT_NAME = "result"

classiq/interface/executor/estimation.py

@@ -1,7 +1,7 @@
 import pydantic
 
 from classiq.interface.chemistry.operator import PauliOperators
-from classiq.interface.executor.quantum_program import QuantumProgram
+from classiq.interface.executor.quantum_code import QuantumCode
 
 
 class OperatorsEstimation(pydantic.BaseModel):
@@ -10,5 +10,5 @@ class OperatorsEstimation(pydantic.BaseModel):
     by a quantum program.
     """
 
-    quantum_program: QuantumProgram
+    quantum_program: QuantumCode
     operators: PauliOperators