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

classiq/interface/analyzer/cytoscape_graph.py

@@ -1,11 +1,10 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class CytoScapePosition(pydantic.BaseModel):
     x: int = pydantic.Field(
@@ -18,21 +17,28 @@ class CytoScapePosition(pydantic.BaseModel):
 
 class CytoScapeEdgeData(pydantic.BaseModel):
     source: str = pydantic.Field(
-        default=..., description="the Id of the Node that is the Source of the edge"
+        default=" ", description="the Id of the Node that is the Source of the edge"
     )
     target: str = pydantic.Field(
-        default=..., description="the Id of the Node that is the Target the edge"
+        default=" ", description="the Id of the Node that is the Target the edge"
     )
 
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_values(cls, values: dict[str, Any]) -> dict[str, Any]:
+        values["source"] = str(values["source"]) or " "
+        values["target"] = str(values["target"]) or " "
+        return values
+
 
 class CytoScapeEdge(pydantic.BaseModel):
     data: CytoScapeEdgeData = pydantic.Field(
-        default=..., description="Edge's Data, mainly the source and target of the Edge"
+        description="Edge's Data, mainly the source and target of the Edge"
     )
 
 
 class CytoScapeNode(pydantic.BaseModel):
-    data: Dict[str, Any] = pydantic.Field(
+    data: dict[str, Any] = pydantic.Field(
         default=...,
         description="Data of the Node, such as label, and color, can be of free form",
     )
@@ -42,11 +48,11 @@ class CytoScapeNode(pydantic.BaseModel):
 
 
 class CytoScapeGraph(pydantic.BaseModel):
-    nodes: List[CytoScapeNode] = pydantic.Field(
+    nodes: list[CytoScapeNode] = pydantic.Field(
         default_factory=list,
         description="Nodes of the Graph",
     )
-    edges: List[CytoScapeEdge] = pydantic.Field(
+    edges: list[CytoScapeEdge] = pydantic.Field(
         default_factory=list,
         description="Edges of the Graph",
     )

classiq/interface/analyzer/result.py

@@ -1,17 +1,16 @@
-from typing import Dict, List, Literal, Optional, Set, Tuple, Union
-from uuid import UUID
+from typing import Annotated, Literal, Optional, Union
 
 import pydantic
-from pydantic import AnyHttpUrl, Field
-from typing_extensions import Annotated
+from pydantic import Field
+from typing_extensions import Self
 
+from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
-Match = List[List[int]]
+Match = list[list[int]]
 
 
 class GraphStatus(StrEnum):
@@ -29,20 +28,16 @@ class RbResults(VersionedModel):
     average_error: float
     A: float
     B: float
-    success_probability: List[float]
-    parameters_error: Tuple[float, ...]
+    success_probability: list[float]
+    parameters_error: tuple[float, ...]
 
 
 class DataID(pydantic.BaseModel):
-    id: UUID
+    id: str
 
 
 class QasmCode(pydantic.BaseModel):
-    code: str
-
-
-class PreSignedS3Url(VersionedModel):
-    url: AnyHttpUrl
+    code: str = Field(..., max_length=MAX_FILE_LENGTH)
 
 
 class AnalysisStatus(StrEnum):
@@ -62,28 +57,29 @@ class BasisGates(StrEnum):
 
 
 class HardwareComparisonInformation(pydantic.BaseModel):
-    devices: List[str] = pydantic.Field(
+    devices: list[str] = pydantic.Field(
         default=..., description="Device which is used for the transpilation."
     )
-    providers: List[str] = pydantic.Field(
+    providers: list[str] = pydantic.Field(
         default=..., description="Provider cloud of the device."
     )
-    depth: List[pydantic.NonNegativeInt] = pydantic.Field(
+    depth: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Circuit depth."
     )
-    multi_qubit_gate_count: List[pydantic.NonNegativeInt] = pydantic.Field(
+    multi_qubit_gate_count: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Number of multi qubit gates."
     )
-    total_gate_count: List[pydantic.NonNegativeInt] = pydantic.Field(
+    total_gate_count: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Number of total gates."
     )
 
-    @pydantic.root_validator
-    def validate_equal_length(cls, values: Dict[str, list]) -> Dict[str, list]:
+    @pydantic.model_validator(mode="after")
+    def validate_equal_length(self) -> Self:
+        values = self.model_dump()
         lengths = list(map(len, values.values()))
         if len(set(lengths)) != 1:
             raise ClassiqValueError("All lists should have the same length")
-        return values
+        return self
 
 
 # TODO: copy the types for `devices` & `providers` from `HardwareComparisonInformation`
@@ -108,32 +104,32 @@ class SingleHardwareInformation(pydantic.BaseModel):
 
 class HardwareComparisonData(VersionedModel):
     kind: Literal["hardware_comparison"] = Field(default="hardware_comparison")
-    data: List[SingleHardwareInformation]
+    data: list[SingleHardwareInformation]
 
 
 HardwareComparisonGraphType = Annotated[
     Union[HardwareComparisonData, GraphResult], Field(discriminator="kind")
 ]
 
-_HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
-    s.upper(): s.capitalize() for s in SingleHardwareInformation.__fields__
+_HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: dict[str, str] = {
+    s.upper(): s.capitalize() for s in SingleHardwareInformation.model_fields
 }
 
 
 class HardwareComparisonDataColumns(pydantic.BaseModel):
-    columns: Dict[str, str] = _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES
+    columns: dict[str, str] = _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES
 
 
 class AvailableHardware(pydantic.BaseModel):
-    ibm_quantum: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    ibm_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available IBM Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    azure_quantum: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    azure_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available Azure Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    amazon_braket: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    amazon_braket: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available Amazon Braket devices with boolean indicates if a given device has enough qubits.",
     )
@@ -166,7 +162,7 @@ class QuantumCircuitProperties(pydantic.BaseModel):
 
 
 class NativeQuantumCircuitProperties(QuantumCircuitProperties):
-    native_gates: Set[BasisGates] = pydantic.Field(
+    native_gates: set[BasisGates] = pydantic.Field(
         default=..., description="Native gates used for decomposition"
     )
 

classiq/interface/applications/qsvm.py

@@ -1,27 +1,19 @@
-from collections.abc import Sequence
+from collections.abc import Iterable as IterableType, Sequence
 from typing import (
-    TYPE_CHECKING,
     Any,
-    Iterable as IterableType,
-    List,
     Optional,
-    Tuple,
     Union,
 )
 
 import numpy as np
 import pydantic
 from numpy.typing import ArrayLike
-from pydantic import BaseModel
+from pydantic import ConfigDict, field_validator
 
-if TYPE_CHECKING:
-    from pydantic.typing import AnyClassMethod
-
-from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-DataList = List[List[float]]
-LabelsInt = List[int]
+DataList = list[list[float]]
+LabelsInt = list[int]
 
 
 def listify(obj: Union[IterableType, ArrayLike]) -> list:
@@ -35,16 +27,15 @@ def listify(obj: Union[IterableType, ArrayLike]) -> list:
         return list(obj)  # type: ignore[arg-type]
 
 
-class QSVMPreferences(BaseModel):
-    execution_preferences: ExecutionPreferences
-    l2_norm_regularization_factor: float = 0.001
-
+def validate_array_to_list(name: str) -> Any:
+    @field_validator(name, mode="before")
+    def _listify(cls: type[pydantic.BaseModel], value: Any) -> Any:
+        return listify(value)
 
-def validate_array_to_list(name: str) -> "AnyClassMethod":
-    return pydantic.validator(name, pre=True, allow_reuse=True)(listify)
+    return _listify
 
 
-Shape = Tuple[int, ...]
+Shape = tuple[int, ...]
 
 
 class QSVMInternalState(VersionedModel):
@@ -96,18 +87,18 @@ class QSVMData(VersionedModel):
     data: DataList
     labels: Optional[LabelsInt] = None
     internal_state: Optional[QSVMInternalState] = None
-    preferences: QSVMPreferences
-
-    class Config:
-        smart_union = True
-        extra = "forbid"
+    model_config = ConfigDict(extra="forbid")
 
-    @pydantic.validator("data", pre=True)
-    def set_data(cls, data):
+    @pydantic.field_validator("data", mode="before")
+    @classmethod
+    def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
         return listify(data)
 
-    @pydantic.validator("labels", pre=True)
-    def set_labels(cls, labels):
+    @pydantic.field_validator("labels", mode="before")
+    @classmethod
+    def set_labels(
+        cls, labels: Optional[Union[IterableType, ArrayLike]]
+    ) -> Optional[list]:
         if labels is None:
             return None
         else:
@@ -123,4 +114,4 @@ class QSVMPredictResult(VersionedModel):
 
 
 Data = Union[DataList, np.ndarray]
-Labels = Union[List[Any], np.ndarray]
+Labels = Union[list[Any], np.ndarray]

classiq/interface/ast_node.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+from classiq.interface.source_reference import SourceReference
+
+
+class ASTNode(HashablePydanticBaseModel):
+    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
+
+
+class HashableASTNode(ASTNode, HashablePydanticBaseModel):
+    pass