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

classiq/qmod/symbolic.py

@@ -1,10 +1,21 @@
 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,
+    get_args,
+    get_origin,
+    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, QParam, create_param
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -15,20 +26,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 +45,15 @@ 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 get_origin(return_type) is QParam:
+        return_type = get_args(return_type)[0]
+
+    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 +66,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 +286,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-0.39.0.dist-info → classiq-0.40.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.39.0
+Version: 0.40.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary