classiq 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/qmod/symbolic.py

@@ -1,10 +1,19 @@
 import sys
-from typing import List, Optional, Tuple, Type, get_args, get_origin, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    overload,
+)
 
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
-from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
+from classiq.qmod.qmod_parameter import CParam, CParamScalar, create_param
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -15,20 +24,18 @@ GoldenRatio = SymbolicExpr("GoldenRatio")
 EulerGamma = SymbolicExpr("EulerGamma")
 Catalan = SymbolicExpr("Catalan")
 
+T = TypeVar("T", bound=CParam)
+
 
 @overload
-def symbolic_function(
-    *args: SymbolicTypes, return_type: None = None
-) -> QParamScalar: ...
+def symbolic_function(*args: Any, return_type: None = None) -> CParamScalar: ...
 
 
 @overload
-def symbolic_function(*args: SymbolicTypes, return_type: Type[QParam]) -> QParam: ...
+def symbolic_function(*args: Any, return_type: Type[T]) -> T: ...
 
 
-def symbolic_function(
-    *args: SymbolicTypes, return_type: Optional[Type[QParam]] = None
-) -> QParam:
+def symbolic_function(*args: Any, return_type: Optional[Type[T]] = None) -> CParam:
     qmodule = (
         model_state_container.QMODULE
     )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
@@ -36,14 +43,12 @@ def symbolic_function(
     expr = f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})"
 
     if return_type is None:
-        return QParamScalar(expr)
+        return CParamScalar(expr)
 
-    if get_origin(return_type) is not QParam:
-        raise ClassiqValueError(
-            f"Unsupported return type for symbolic function: {return_type}"
-        )
+    if TYPE_CHECKING:
+        assert return_type is not None
 
-    qmod_type = python_type_to_qmod(get_args(return_type)[0], qmodule=qmodule)
+    qmod_type = python_type_to_qmod(return_type, qmodule=qmodule)
     if qmod_type is None:
         raise ClassiqValueError(
             f"Unsupported return type for symbolic function: {return_type}"
@@ -56,211 +61,211 @@ def symbolic_function(
     )
 
 
-def sin(x: SymbolicTypes) -> QParamScalar:
+def sin(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cos(x: SymbolicTypes) -> QParamScalar:
+def cos(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def tan(x: SymbolicTypes) -> QParamScalar:
+def tan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cot(x: SymbolicTypes) -> QParamScalar:
+def cot(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sec(x: SymbolicTypes) -> QParamScalar:
+def sec(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def csc(x: SymbolicTypes) -> QParamScalar:
+def csc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asin(x: SymbolicTypes) -> QParamScalar:
+def asin(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acos(x: SymbolicTypes) -> QParamScalar:
+def acos(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def atan(x: SymbolicTypes) -> QParamScalar:
+def atan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acot(x: SymbolicTypes) -> QParamScalar:
+def acot(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asec(x: SymbolicTypes) -> QParamScalar:
+def asec(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acsc(x: SymbolicTypes) -> QParamScalar:
+def acsc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sinh(x: SymbolicTypes) -> QParamScalar:
+def sinh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def cosh(x: SymbolicTypes) -> QParamScalar:
+def cosh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def tanh(x: SymbolicTypes) -> QParamScalar:
+def tanh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def coth(x: SymbolicTypes) -> QParamScalar:
+def coth(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sech(x: SymbolicTypes) -> QParamScalar:
+def sech(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def csch(x: SymbolicTypes) -> QParamScalar:
+def csch(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asinh(x: SymbolicTypes) -> QParamScalar:
+def asinh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acosh(x: SymbolicTypes) -> QParamScalar:
+def acosh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def atanh(x: SymbolicTypes) -> QParamScalar:
+def atanh(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def acoth(x: SymbolicTypes) -> QParamScalar:
+def acoth(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def asech(x: SymbolicTypes) -> QParamScalar:
+def asech(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def exp(x: SymbolicTypes) -> QParamScalar:
+def exp(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def log(x: SymbolicTypes, base: SymbolicTypes = E) -> QParamScalar:
+def log(x: SymbolicTypes, base: SymbolicTypes = E) -> CParamScalar:
     return symbolic_function(x, base)
 
 
-def ln(x: SymbolicTypes) -> QParamScalar:
+def ln(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def sqrt(x: SymbolicTypes) -> QParamScalar:
+def sqrt(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def abs(x: SymbolicTypes) -> QParamScalar:
+def abs(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def floor(x: SymbolicTypes) -> QParamScalar:
+def floor(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def ceiling(x: SymbolicTypes) -> QParamScalar:
+def ceiling(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def erf(x: SymbolicTypes) -> QParamScalar:
+def erf(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def erfc(x: SymbolicTypes) -> QParamScalar:
+def erfc(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def gamma(x: SymbolicTypes) -> QParamScalar:
+def gamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def beta(x: SymbolicTypes) -> QParamScalar:
+def beta(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besselj(x: SymbolicTypes) -> QParamScalar:
+def besselj(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bessely(x: SymbolicTypes) -> QParamScalar:
+def bessely(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besseli(x: SymbolicTypes) -> QParamScalar:
+def besseli(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def besselk(x: SymbolicTypes) -> QParamScalar:
+def besselk(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def dirichlet_eta(x: SymbolicTypes) -> QParamScalar:
+def dirichlet_eta(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def polygamma(x: SymbolicTypes) -> QParamScalar:
+def polygamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def loggamma(x: SymbolicTypes) -> QParamScalar:
+def loggamma(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def factorial(x: SymbolicTypes) -> QParamScalar:
+def factorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def binomial(x: SymbolicTypes) -> QParamScalar:
+def binomial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def subfactorial(x: SymbolicTypes) -> QParamScalar:
+def subfactorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def primorial(x: SymbolicTypes) -> QParamScalar:
+def primorial(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bell(x: SymbolicTypes) -> QParamScalar:
+def bell(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def bernoulli(x: SymbolicTypes) -> QParamScalar:
+def bernoulli(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def euler(x: SymbolicTypes) -> QParamScalar:
+def euler(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def catalan(x: SymbolicTypes) -> QParamScalar:
+def catalan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> QParamScalar:  # noqa: N802
+def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
     return symbolic_function(*args)
 
 
-def max(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+def max(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x, y)
 
 
-def min(x: SymbolicTypes, y: SymbolicTypes) -> QParamScalar:
+def min(x: SymbolicTypes, y: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x, y)
 
 
@@ -276,7 +281,7 @@ def logical_not(x: SymbolicTypes) -> SymbolicExpr:
     return SymbolicExpr._unary_op(x, "not")
 
 
-def mod_inverse(a: SymbolicTypes, m: SymbolicTypes) -> QParamScalar:
+def mod_inverse(a: SymbolicTypes, m: SymbolicTypes) -> CParamScalar:
     return symbolic_function(a, m)
 
 

classiq/qmod/symbolic_expr.py

@@ -12,7 +12,7 @@ class Symbolic:
         return self._expr
 
     def __repr__(self) -> str:
-        return self._expr
+        return self.__str__()
 
     def __bool__(self) -> bool:
         try:

classiq/qmod/symbolic_type.py

@@ -1,8 +1,5 @@
 from typing import Tuple, Union
 
-from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
-SymbolicTypes = Union[
-    QParam, SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]
-]
+SymbolicTypes = Union[SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]]

classiq/qmod/utilities.py

@@ -1,7 +1,12 @@
+import inspect
+import itertools
 import keyword
 import sys
+from types import FrameType
 from typing import get_args, get_origin
 
+from classiq.interface.ast_node import SourceReference
+
 DEFAULT_DECIMAL_PRECISION = 4
 
 
@@ -25,3 +30,27 @@ def version_portable_get_args(py_type: type) -> tuple:
         return get_args(py_type)  # The result of __class_getitem__
     else:
         return get_args(py_type)[0]
+
+
+def get_source_ref(frame: FrameType) -> SourceReference:
+    filename = inspect.getfile(frame)
+    lineno = frame.f_lineno
+    if sys.version_info[0:2] < (3, 11) or frame.f_lasti < 0:
+        source_ref = SourceReference(
+            file_name=filename,
+            start_line=lineno,
+            start_column=-1,
+            end_line=-1,
+            end_column=-1,
+        )
+    else:
+        positions_gen = frame.f_code.co_positions()
+        positions = next(itertools.islice(positions_gen, frame.f_lasti // 2, None))
+        source_ref = SourceReference(
+            file_name=filename,
+            start_line=positions[0],
+            start_column=positions[2],
+            end_line=positions[1],
+            end_column=positions[3],
+        )
+    return source_ref

classiq/synthesis.py

@@ -5,8 +5,7 @@ import pydantic
 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.common_model_types import ModelInput, SerializedModelInput
-from classiq.interface.model.model import SerializedModel
+from classiq.interface.model.model import Model, SerializedModel
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
@@ -15,9 +14,9 @@ SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
 
 
 async def synthesize_async(
-    serialized_model: SerializedModelInput,
+    serialized_model: SerializedModel,
 ) -> SerializedQuantumProgram:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    model = pydantic.parse_raw_as(Model, serialized_model)
     quantum_program = await ApiWrapper.call_generation_task(model)
     return SerializedQuantumProgram(quantum_program.json(indent=2))
 
@@ -26,27 +25,27 @@ synthesize = syncify_function(synthesize_async)
 
 
 def set_preferences(
-    serialized_model: SerializedModelInput, preferences: Preferences
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel, preferences: Preferences
+) -> SerializedModel:
+    model = pydantic.parse_raw_as(Model, serialized_model)
     model.preferences = preferences
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
 
 
 def set_constraints(
-    serialized_model: SerializedModelInput, constraints: Constraints
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel, constraints: Constraints
+) -> SerializedModel:
+    model = pydantic.parse_raw_as(Model, serialized_model)
     model.constraints = constraints
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
 
 
 def set_execution_preferences(
-    serialized_model: SerializedModelInput, execution_preferences: ExecutionPreferences
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel, execution_preferences: ExecutionPreferences
+) -> SerializedModel:
+    model = pydantic.parse_raw_as(Model, serialized_model)
     model.execution_preferences = execution_preferences
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
 
 
 __all__ = [

{classiq-0.39.0.dist-info → classiq-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.39.0
+Version: 0.41.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -31,6 +31,7 @@ Provides-Extra: analyzer-sdk
 Provides-Extra: qml
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.5,<6.6)
+Requires-Dist: black (>=24.0,<25.0)
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: ipywidgets (>=7.7.1,<8.0.0) ; extra == "analyzer-sdk"
 Requires-Dist: keyring (>=23.5.0,<24.0.0)
@@ -38,11 +39,11 @@ Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
 Requires-Dist: numpy (>=1.20.1,<2.0.0)
-Requires-Dist: packaging (>=21.3,<22.0)
-Requires-Dist: pandas (>=1.4.0,<2.0.0)
+Requires-Dist: packaging (>=22.0,<23.0)
+Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
 Requires-Dist: pydantic (>=1.9.1,<2.0.0)
-Requires-Dist: scipy (==1.10.1)
+Requires-Dist: scipy (>=1.10.1,<2.0.0)
 Requires-Dist: sympy (>=1.9.0,<1.11.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"