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

classiq/qmod/quantum_callable.py

@@ -12,6 +12,7 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
+from classiq.interface.ast_node import SourceReference
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
@@ -19,7 +20,8 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CInt
+from classiq.qmod.utilities import get_source_ref
 
 if TYPE_CHECKING:
     from classiq.qmod.quantum_expandable import QTerminalCallable
@@ -42,8 +44,9 @@ class QCallable(Generic[P], ABC):
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
+        source_ref = get_source_ref(sys._getframe(1))
         QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-            self.create_quantum_function_call(*args, **kwargs)
+            self.create_quantum_function_call(source_ref, *args, **kwargs)
         )
         return
 
@@ -60,7 +63,7 @@ class QCallable(Generic[P], ABC):
 
     @abstractmethod
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
         raise NotImplementedError()
 
@@ -68,7 +71,8 @@ class QCallable(Generic[P], ABC):
 class QCallableList(QCallable, Generic[P], ABC):
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
-        def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":
+        def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
             raise NotImplementedError()

classiq/qmod/quantum_expandable.py

@@ -17,6 +17,7 @@ from typing import (
 
 from typing_extensions import Self
 
+from classiq.interface.ast_node import SourceReference
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -32,10 +33,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumLambdaFunction,
-    QuantumOperand,
-)
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -45,12 +43,12 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
+from classiq.qmod.qmod_parameter import CInt, CParam, CParamScalar, create_param
 from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.utilities import mangle_keyword
 
-ArgType = Union[QParam, QVar, QCallable]
+ArgType = Union[CParam, QVar, QCallable]
 
 
 class QExpandable(QCallable, QExpandableInterface, ABC):
@@ -112,9 +110,11 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         return result
 
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
-        return _create_quantum_function_call(self.func_decl, None, *args, **kwargs)
+        return _create_quantum_function_call(
+            self.func_decl, None, source_ref_, *args, **kwargs
+        )
 
 
 class QLambdaFunction(QExpandable):
@@ -141,7 +141,7 @@ class QTerminalCallable(QCallable):
     def __init__(
         self,
         decl: QuantumFunctionDeclaration,
-        index_: Optional[Union[int, QParamScalar]] = None,
+        index_: Optional[Union[int, CParamScalar]] = None,
     ) -> None:
         self._decl = decl
         self._index = index_
@@ -150,51 +150,53 @@ class QTerminalCallable(QCallable):
     def is_list(self) -> bool:
         return isinstance(self._decl, QuantumOperandDeclaration) and self._decl.is_list
 
-    def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":
+    def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
         if not self.is_list:
             raise ClassiqValueError("Cannot index a non-list operand")
         if isinstance(key, slice):
             raise NotImplementedError("Operand lists don't support slicing")
-        if isinstance(key, QParam) and not isinstance(key, QParamScalar):
+        if isinstance(key, CParam) and not isinstance(key, CParamScalar):
             raise ClassiqValueError("Non-classical parameter for slicing")
         return QTerminalCallable(self._decl, key)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<func>) is not supported for quantum callables - use <func>.len() instead (Only if it is an operand list)"
+            "len(<func>) is not supported for quantum callables - use <func>.len instead (Only if it is an operand list)"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
-        def len(self) -> QParamScalar:
+        @property
+        def len(self) -> CParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
-            return QParamScalar(f"len({self.func_decl.name})")
+            return CParamScalar(f"{self.func_decl.name}.len")
 
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         return self._decl
 
     def create_quantum_function_call(
-        self, *args: Any, **kwargs: Any
+        self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
         if self.is_list and self._index is None:
             raise ClassiqValueError(
                 f"Quantum operand {self.func_decl.name!r} is a list and must be indexed"
             )
         return _create_quantum_function_call(
-            self.func_decl, self._index, *args, **kwargs
+            self.func_decl, self._index, source_ref_, *args, **kwargs
         )
 
 
 @overload
 def prepare_arg(
-    arg_decl: PositionalArg, val: Union[QCallable, Callable[[Any], None]]
-) -> QuantumOperand: ...
+    arg_decl: PositionalArg, val: Union[QCallable, Callable[..., None]]
+) -> QuantumLambdaFunction: ...
 
 
 @overload
@@ -279,7 +281,8 @@ def _prepare_args(
 
 def _create_quantum_function_call(
     decl_: QuantumFunctionDeclaration,
-    index_: Optional[Union[QParamScalar, int]] = None,
+    index_: Optional[Union[CParamScalar, int]] = None,
+    source_ref_: Optional[SourceReference] = None,
     *args: Any,
     **kwargs: Any,
 ) -> QuantumFunctionCall:
@@ -307,4 +310,6 @@ def _create_quantum_function_call(
             index=Expression(expr=str(index_)), name=function_ident
         )
 
-    return QuantumFunctionCall(function=function_ident, positional_args=prepared_args)
+    return QuantumFunctionCall(
+        function=function_ident, positional_args=prepared_args, source_ref=source_ref_
+    )

classiq/qmod/quantum_function.py

@@ -1,8 +1,11 @@
 import ast
 import functools
+import warnings
+from inspect import isclass
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.functions.classical_type import CStructBase
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.model.model import Model, SerializedModel
@@ -15,7 +18,7 @@ from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CParam, QParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
@@ -34,6 +37,10 @@ def create_model(
     preferences: Optional[Preferences] = None,
     classical_execution_function: Optional[CFunc] = None,
 ) -> SerializedModel:
+    if entry_point.func_decl.name != "main":
+        raise ClassiqError(
+            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
+        )
     return entry_point.create_model(
         constraints, execution_preferences, preferences, classical_execution_function
     ).get_model()
@@ -42,6 +49,18 @@ def create_model(
 class QFunc(QExpandable):
     def __init__(self, py_callable: Callable) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
+        if any(
+            get_origin(annotation) == QParam
+            for annotation in py_callable.__annotations__.values()
+        ):
+            warnings.warn(
+                "QParam is deprecated and will be removed in a future release. Use the "
+                "new classical parameter types instead:\n    * QParam[int] -> CInt\n    * QParam[float] "
+                "-> CReal\n    * QParam[bool] -> CBool\n    * QParam[list[int]] -> "
+                "CArray[CInt]",
+                category=DeprecationWarning,
+                stacklevel=4,
+            )
         super().__init__(py_callable)
         functools.update_wrapper(self, py_callable)
 
@@ -140,7 +159,10 @@ ILLEGAL_PARAM_ERROR = "Unsupported type hint '{annotation}' for argument '{name}
 
 
 class IllegalParamsError(ClassiqError):
-    _HINT = "\nNote - QMOD functions can declare classical parameters using the type hint 'QParam'."
+    _HINT = (
+        "\nNote - QMOD functions can declare classical parameters using the type hints "
+        "'CInt', 'CReal', 'CBool', and 'CArray'."
+    )
 
     def __init__(self, message: str) -> None:
         super().__init__(message + self._HINT)
@@ -153,6 +175,11 @@ def _validate_no_gen_params(annotations: Dict[str, Any]) -> None:
         if not (
             name == "return"
             or get_origin(annotation) is QParam
+            or isclass(annotation)
+            and issubclass(annotation, CParam)
+            or isclass(annotation)
+            and issubclass(annotation, CStructBase)
+            or get_origin(annotation) is CArray
             or (get_origin(annotation) or annotation) is QCallable
             or (get_origin(annotation) or annotation) is QCallableList
             or QVar.from_type_hint(annotation) is not None

classiq/qmod/symbolic.py

@@ -1,10 +1,21 @@
 import sys
-from typing import 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)
 
 
@@ -346,5 +356,5 @@ __all__ = [
 ]
 
 
-def __dir__():
+def __dir__() -> List[str]:
     return __all__

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.38.0.dist-info → classiq-0.40.0.dist-info}/METADATA

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