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

classiq/interface/model/quantum_type.py

@@ -1,30 +1,32 @@
-from typing import Any, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import Extra, Field
-from typing_extensions import Annotated
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
 
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQBitProxy,
     QmodQNumProxy,
     QmodQScalarProxy,
 )
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
-from classiq.exceptions import ClassiqValueError
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 
 
-class QuantumType(HashablePydanticBaseModel):
-    class Config:
-        extra = Extra.forbid
+class QuantumType(HashableASTNode):
+    model_config = ConfigDict(extra="forbid")
 
     _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
 
@@ -46,13 +48,29 @@ class QuantumType(HashablePydanticBaseModel):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
-    def get_proxy(self, name: str) -> QmodSizedProxy:
-        return QmodSizedProxy(size=self.size_in_bits)
+    def get_proxy(self, handle: "HandleBinding") -> QmodSizedProxy:
+        return QmodSizedProxy(handle=handle, size=self.size_in_bits)
+
+    @property
+    def qmod_type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def is_instantiated(self) -> bool:
+        raise NotImplementedError
+
+    @property
+    def is_evaluated(self) -> bool:
+        raise NotImplementedError
 
 
 class QuantumScalar(QuantumType):
-    def get_proxy(self, name: str) -> QmodQScalarProxy:
-        return QmodQScalarProxy(name, size=self.size_in_bits)
+    def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
+        return QmodQScalarProxy(handle, size=self.size_in_bits)
 
 
 class QuantumBit(QuantumScalar):
@@ -62,47 +80,120 @@ class QuantumBit(QuantumScalar):
         super().__init__(**kwargs)
         self._size_in_bits = 1
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "qbit")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "QBit"
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQBitProxy:
+        return QmodQBitProxy(handle)
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
+
+    @property
+    def is_instantiated(self) -> bool:
+        return True
 
-class QuantumArray(QuantumType):
-    length: Optional[Expression]
+    @property
+    def is_evaluated(self) -> bool:
+        return True
 
 
-class QuantumBitvector(QuantumArray):
+class QuantumBitvector(QuantumType):
+    element_type: "ConcreteQuantumType" = Field(
+        discriminator="kind", default_factory=QuantumBit
+    )
     kind: Literal["qvec"]
+    length: Optional[Expression] = Field(default=None)
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "qvec")
 
     def _update_size_in_bits_from_declaration(self) -> None:
-        if self.length is not None and self.length.is_evaluated():
-            self._size_in_bits = self.length.to_int_value()
+        self.element_type._update_size_in_bits_from_declaration()
+        if self.element_type.has_size_in_bits and self.has_length:
+            assert self.length is not None
+            self._size_in_bits = (
+                self.element_type.size_in_bits * self.length.to_int_value()
+            )
+
+    @property
+    def has_length(self) -> bool:
+        return self.length is not None and self.length.is_evaluated()
+
+    @property
+    def length_value(self) -> int:
+        if not self.has_length:
+            raise ClassiqValueError(
+                "Tried to access unevaluated length of quantum array"
+            )
+        assert self.length is not None
+        return self.length.to_int_value()
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQArrayProxy:
+        element_size = self.element_type.size_in_bits
+        assert self.size_in_bits % element_size == 0
+        return QmodQArrayProxy(
+            handle,
+            self.element_type,
+            element_size,
+            self.size_in_bits // element_size,
+        )
+
+    @property
+    def qmod_type_name(self) -> str:
+        element_type = [self.element_type.qmod_type_name]
+        length = [self.length.expr] if self.length is not None else []
+        return f"QArray[{', '.join(element_type + length)}]"
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
+
+    @property
+    def is_instantiated(self) -> bool:
+        return self.length is not None and self.element_type.is_instantiated
+
+    @property
+    def is_evaluated(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.element_type.is_evaluated
+        )
 
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
 
-    size: Optional[Expression] = pydantic.Field()
-    is_signed: Optional[Expression] = pydantic.Field()
-    fraction_digits: Optional[Expression] = pydantic.Field()
+    size: Optional[Expression] = pydantic.Field(default=None)
+    is_signed: Optional[Expression] = pydantic.Field(default=None)
+    fraction_digits: Optional[Expression] = pydantic.Field(default=None)
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "qnum")
 
-    @pydantic.root_validator
-    def _validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        has_sign = values["is_signed"] is not None
-        has_fraction_digits = values["fraction_digits"] is not None
-        if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
+    @pydantic.model_validator(mode="after")
+    def _validate_fields(self) -> Self:
+        has_sign = self.is_signed is not None
+        has_fraction_digits = self.fraction_digits is not None
+        if (has_sign and not has_fraction_digits) or (
+            not has_sign and has_fraction_digits
+        ):
             raise ClassiqValueError(
                 "Assign neither or both of is_signed and fraction_digits"
             )
-        return values
+        return self
 
     @property
     def has_sign(self) -> bool:
@@ -126,19 +217,56 @@ class QuantumNumeric(QuantumScalar):
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
 
-    def get_proxy(self, name: str) -> QmodQNumProxy:
+    def get_proxy(self, handle: "HandleBinding") -> QmodQNumProxy:
         return QmodQNumProxy(
-            name,
+            handle,
             size=self.size_in_bits,
             fraction_digits=self.fraction_digits_value,
             is_signed=self.sign_value,
         )
 
+    @property
+    def qmod_type_name(self) -> str:
+        if (
+            self.size is not None
+            and self.is_signed is not None
+            and self.fraction_digits is not None
+        ):
+            return f"QNum[{self.size.expr}, {self.is_signed.expr}, {self.fraction_digits.expr}]"
+        return "QNum"
 
-ConcreteQuantumType = Annotated[
-    Union[QuantumBit, QuantumBitvector, QuantumNumeric],
-    Field(discriminator="kind", default_factory=QuantumBitvector),
-]
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
+
+    @property
+    def is_instantiated(self) -> bool:
+        return self.size is not None
+
+    @property
+    def is_evaluated(self) -> bool:
+        if self.size is None or not self.size.is_evaluated():
+            return False
+        if self.is_signed is not None and not self.is_signed.is_evaluated():
+            return False
+        return not (
+            self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
+        )
+
+
+class RegisterQuantumType(BaseModel):
+    quantum_types: "ConcreteQuantumType"
+    size: int = Field(default=1)
+
+    @property
+    def qmod_type_name(self) -> str:
+        try:
+            return self.quantum_types.qmod_type_name.split("[")[0]
+        except AttributeError:
+            return "default"
+
+
+RegisterQuantumTypeDict = dict[str, RegisterQuantumType]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:
@@ -165,3 +293,12 @@ def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
         is_signed=signed,
         fraction_places=fraction_places,
     )
+
+
+def quantum_type_to_register_quantum_type(
+    qtype: QuantumType, size: int
+) -> RegisterQuantumType:
+    return RegisterQuantumType(
+        quantum_types=qtype,
+        size=size,
+    )

classiq/interface/model/quantum_variable_declaration.py

@@ -1,29 +1,7 @@
-from typing import Any, Mapping, Optional
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 
-import pydantic
-from pydantic import BaseModel
 
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.quantum_type import (
-    ConcreteQuantumType,
-    QuantumBitvector,
-    QuantumNumeric,
-)
-
-
-class QuantumVariableDeclaration(BaseModel):
+class QuantumVariableDeclaration(ASTNode):
     name: str
     quantum_type: ConcreteQuantumType
-    size: Optional[Expression] = pydantic.Field(default=None)
-
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        if size is not None:
-            quantum_type = values.get("quantum_type")
-            if isinstance(quantum_type, QuantumBitvector):
-                quantum_type.length = size
-            elif isinstance(quantum_type, QuantumNumeric):
-                quantum_type.size = size
-        return size

classiq/interface/model/repeat.py

@@ -0,0 +1,15 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Repeat(QuantumOperation):
+    kind: Literal["Repeat"]
+
+    iter_var: str
+    count: Expression
+    body: "StatementBlock"

classiq/interface/model/statement_block.py

@@ -1,7 +1,16 @@
-from typing import List, Union
+from typing import Annotated, Union
 
+from pydantic import Field
+
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -9,24 +18,41 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
+from classiq.interface.model.within_apply_operation import WithinApply
 
-ConcreteQuantumStatement = Union[
-    QuantumFunctionCall,
-    ArithmeticOperation,
-    AmplitudeLoadingOperation,
-    VariableDeclarationStatement,
-    BindOperation,
-    InplaceBinaryOperation,
-    QuantumIfOperation,
-    WithinApplyOperation,
+ConcreteQuantumStatement = Annotated[
+    Union[
+        Allocate,
+        QuantumFunctionCall,
+        ArithmeticOperation,
+        AmplitudeLoadingOperation,
+        VariableDeclarationStatement,
+        BindOperation,
+        InplaceBinaryOperation,
+        Repeat,
+        Power,
+        Invert,
+        ClassicalIf,
+        Control,
+        WithinApply,
+        PhaseOperation,
+    ],
+    Field(..., discriminator="kind"),
 ]
 
-StatementBlock = List[ConcreteQuantumStatement]
+StatementBlock = list[ConcreteQuantumStatement]
 
-QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)
+Control.model_rebuild()
+QuantumLambdaFunction.model_rebuild()
+Repeat.model_rebuild()
+Power.model_rebuild()
+Invert.model_rebuild()
+WithinApply.model_rebuild()
+ClassicalIf.model_rebuild()
+NativeFunctionDefinition.model_rebuild()
+PhaseOperation.model_rebuild()

classiq/interface/model/validation_handle.py

@@ -1,27 +1,34 @@
 import dataclasses
+from collections.abc import Mapping
 from enum import Enum
-from typing import List, Mapping, Optional, Set
+from typing import Optional
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.handle_binding import HandleBinding
 
-from classiq.exceptions import ClassiqError
-
 
 class HandleState(Enum):
     INITIALIZED = 0
     UNINITIALIZED = 1
     ERRORED = 2
 
+    def __invert__(self) -> "HandleState":
+        if self == HandleState.INITIALIZED:
+            return HandleState.UNINITIALIZED
+        if self == HandleState.UNINITIALIZED:
+            return HandleState.INITIALIZED
+        return self
+
 
 @dataclasses.dataclass
 class ValidationHandle:
     _state: HandleState
-    errors: List[str] = dataclasses.field(default_factory=list)
+    errors: list[str] = dataclasses.field(default_factory=list)
 
     def __init__(
         self,
         initial_state: Optional[HandleState] = None,
-        errors: Optional[List[str]] = None,
+        errors: Optional[list[str]] = None,
     ) -> None:
         if initial_state is None and not errors:
             raise ClassiqError("Missing initial state for ValidationHandle")
@@ -44,5 +51,5 @@ class ValidationHandle:
         self._state = HandleState.UNINITIALIZED
 
 
-def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> Set[str]:
+def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> set[str]:
     return {handle_binding.name for handle_binding in io_dict.values()}

classiq/interface/model/variable_declaration_statement.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -5,4 +7,4 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
-    pass
+    kind: Literal["VariableDeclarationStatement"]

classiq/interface/model/within_apply_operation.py

@@ -1,11 +1,13 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
-    from classiq.interface.model.quantum_lambda_function import QuantumOperand
+    from classiq.interface.model.statement_block import StatementBlock
 
 
-class WithinApplyOperation(QuantumOperation):
-    compute: "QuantumOperand"
-    action: "QuantumOperand"
+class WithinApply(QuantumOperation):
+    kind: Literal["WithinApply"]
+
+    compute: "StatementBlock"
+    action: "StatementBlock"

classiq/interface/server/global_versions.py

@@ -1,15 +1,14 @@
-from datetime import datetime
-from typing import Any, Dict
+from datetime import date
+from typing import Any
 
-import pydantic
 from pydantic import BaseModel
 
 
 class DeprecationInfo(BaseModel):
-    deprecation_date: datetime = pydantic.Field()
-    removal_date: datetime = pydantic.Field()
+    deprecation_date: date
+    removal_date: date
 
 
 class GlobalVersions(BaseModel):
-    deprecated: Dict[str, DeprecationInfo] = pydantic.Field()
-    deployed: Dict[str, Any] = pydantic.Field()
+    deprecated: dict[str, DeprecationInfo]
+    deployed: dict[str, Any]

classiq/interface/server/routes.py

@@ -1,8 +1,11 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
-LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
+EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
+PROVIDERS_PREFIX = "/providers"
+
+IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 
 EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
 SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
@@ -18,21 +21,20 @@ ANALYZER_HC_TABLE_GRAPH_FULL_PATH = ANALYZER_PREFIX + ANALYZER_HC_TABLE_GRAPH
 
 ANALYZER_HC_GRAPH_NEW = "/graphs/hardware_connectivity/new"
 
-ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
-ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
-
 TASKS_SUFFIX = "/tasks"
-QUANTUM_PROGRAM_SUFFIX = "/quantum_program"
-ESTIMATE_SUFFIX = "/estimate"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
+ANALYZER_GET_VISUAL_MODEL = "/get_visual_model"
+ANALYZER_GET_IDE_DATA = "/get_ide_data"
 IDE_EVENT_TASK = f"{TASKS_SUFFIX}/event"
 DATA_DOG_EVENT_TASK = f"{TASKS_SUFFIX}/data_dog_event"
 
 ANALYZER_DATA_TASK_UPLOAD_FILE = f"{TASKS_SUFFIX}/data/file_upload"
 ANALYZER_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_DATA_TASK}"
 ANALYZER_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_QASM_TASK}"
+ANALYZER_GET_VISUAL_MODEL_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_VISUAL_MODEL}"
+ANALYZER_GET_IDE_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_IDE_DATA}"
 IDE_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_EVENT_TASK}"
 DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 
@@ -40,9 +42,8 @@ IDE_QASM_TASK = f"{TASKS_SUFFIX}/generated_circuit_from_qasm"
 IDE_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_QASM_TASK}"
 TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
 TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
+TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
-MODEL_GENERATE_PREFIX = "/generate_model"
-CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"
 
 CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
 GROVER_QMOD_PATH = "/generate_model/grover/qmod"
@@ -60,8 +61,6 @@ EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
     EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
 )
-EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
-EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
@@ -70,19 +69,16 @@ GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 
 GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = (
-    SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
-)
-
-FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
-
-GROVER_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/grover"
-
-QMOD_PREFIX = ANALYZER_PREFIX + "/qmods"
-QMOD_METADATA_PATH = QMOD_PREFIX + "/metadata"
-QMOD_FILE_PATH = QMOD_PREFIX + "/file"
+GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
 
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
 )
+
+STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
+
+IQCC_INIT_AUTH_SUFFIX = "/init_auth"
+IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
+IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
+IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX

classiq/interface/source_reference.py

@@ -0,0 +1,59 @@
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+
+
+def _identify_ipynb_cell(file_name: str) -> bool:
+    file_path = Path(file_name)
+    base_file = file_path.name
+    if re.fullmatch(r"\d*\.py", base_file) is None:
+        return False
+    parent_folder = file_path.parent
+    return re.fullmatch(r"ipykernel_\d*", parent_folder.name) is not None
+
+
+def _prepare_file_string(file_name: str) -> str:
+    if _identify_ipynb_cell(file_name):
+        return "ipynb cell "
+    return f"file {os.path.basename(file_name)} "
+
+
+class SourceReference(HashablePydanticBaseModel):
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    file_name: Optional[str] = pydantic.Field(default=None)
+
+    def __str__(self) -> str:
+        file_string = _prepare_file_string(self.file_name) if self.file_name else ""
+        start_character_string = (
+            f" character {self.start_column + 1}" if self.start_column > 0 else ""
+        )
+        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+
+
+class SourceReferencedError(pydantic.BaseModel):
+    error: str
+    source_ref: Optional[SourceReference] = None
+    function: Optional[str] = None
+
+    def __str__(self) -> str:
+        source_referenced_error = (
+            f"{self.error}\n\t\tat {self.source_ref}"
+            if self.source_ref is not None
+            else self.error
+        )
+        function_scoped_error = (
+            f"{source_referenced_error} in function {self.function}"
+            if self.function is not None
+            else source_referenced_error
+        )
+        return function_scoped_error