classiq 0.51.1__py3-none-any.whl → 0.52.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -11,6 +11,12 @@ from classiq.interface.analyzer.result import GraphStatus
 from classiq.interface.chemistry import ground_state_problem, operator
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
+from classiq.interface.execution.iqcc import (
+    IQCCInitAuthData,
+    IQCCInitAuthResponse,
+    IQCCProbeAuthData,
+    IQCCProbeAuthResponse,
+)
 from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     ExecutionJobsQueryResultsV1,
@@ -49,7 +55,7 @@ def _parse_job_response(
     output_type: Type[ResultType],
 ) -> ResultType:
     if job_result.result is not None:
-        return output_type.parse_obj(job_result.result)
+        return output_type.model_validate(job_result.result)
     if job_result.failure_details:
         raise ClassiqAPIError(job_result.failure_details)
 
@@ -68,7 +74,7 @@ class ApiWrapper:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
-        body = json.loads(model.json())
+        body = json.loads(model.model_dump_json())
         return await cls._call_task(
             http_method, url, body, use_versioned_url=use_versioned_url
         )
@@ -126,7 +132,7 @@ class ApiWrapper:
             body=execution_input,
             use_versioned_url=False,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_details(
@@ -140,7 +146,7 @@ class ApiWrapper:
             url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
             use_versioned_url=False,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_result(
@@ -154,7 +160,7 @@ class ApiWrapper:
             use_versioned_url=False,
             headers={CLASSIQ_ACCEPT_HEADER: version},
         )
-        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.parse_obj(
+        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
             data
         )
 
@@ -172,7 +178,7 @@ class ApiWrapper:
             },
             use_versioned_url=False,
         )
-        return ExecutionJobDetailsV1.parse_obj(data)
+        return ExecutionJobDetailsV1.model_validate(data)
 
     @classmethod
     async def call_cancel_execution_job(
@@ -201,7 +207,7 @@ class ApiWrapper:
             },
             use_versioned_url=False,
         )
-        return ExecutionJobsQueryResultsV1.parse_obj(data)
+        return ExecutionJobsQueryResultsV1.model_validate(data)
 
     @classmethod
     async def call_analysis_task(
@@ -213,7 +219,7 @@ class ApiWrapper:
             model=params,
         )
 
-        return analysis_result.Analysis.parse_obj(data)
+        return analysis_result.Analysis.model_validate(data)
 
     @classmethod
     async def call_analyzer_app(
@@ -224,7 +230,7 @@ class ApiWrapper:
             url=routes.ANALYZER_DATA_FULL_PATH,
             model=params,
         )
-        return analysis_result.DataID.parse_obj(data)
+        return analysis_result.DataID.model_validate(data)
 
     @classmethod
     async def get_generated_circuit_from_qasm(
@@ -235,7 +241,7 @@ class ApiWrapper:
             url=routes.IDE_QASM_FULL_PATH,
             model=params,
         )
-        return generator_result.QuantumProgram.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def get_analyzer_app_data(
@@ -245,7 +251,7 @@ class ApiWrapper:
             http_method=HTTPMethod.GET,
             url=f"{routes.ANALYZER_DATA_FULL_PATH}/{params.id}",
         )
-        return generator_result.QuantumProgram.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def call_rb_analysis_task(
@@ -254,10 +260,10 @@ class ApiWrapper:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_RB_FULL_PATH,
-            body=params.dict(),
+            body=params.model_dump(),
         )
 
-        return analysis_result.RbResults.parse_obj(data)
+        return analysis_result.RbResults.model_validate(data)
 
     @classmethod
     async def call_hardware_connectivity_task(
@@ -268,7 +274,7 @@ class ApiWrapper:
             url=routes.ANALYZER_HC_GRAPH_FULL_PATH,
             model=params,
         )
-        return analysis_result.GraphResult.parse_obj(data)
+        return analysis_result.GraphResult.model_validate(data)
 
     @classmethod
     async def call_table_graphs_task(
@@ -320,7 +326,7 @@ class ApiWrapper:
         )
         if not isinstance(data, list):
             raise ClassiqAPIError(f"Unexpected value: {data}")
-        return [HardwareInformation.parse_obj(info) for info in data]
+        return [HardwareInformation.model_validate(info) for info in data]
 
     @classmethod
     async def call_generate_hamiltonian_task(
@@ -332,3 +338,23 @@ class ApiWrapper:
         )
         result = await poller.run_pydantic(problem, timeout_sec=None)
         return _parse_job_response(result, operator.PauliOperator)
+
+    @classmethod
+    async def call_iqcc_init_auth(cls, data: IQCCInitAuthData) -> IQCCInitAuthResponse:
+        response = await cls._call_task_pydantic(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.IQCC_INIT_AUTH_FULL_PATH}",
+            model=data,
+        )
+        return IQCCInitAuthResponse.parse_obj(response)
+
+    @classmethod
+    async def call_iqcc_probe_auth(
+        cls, data: IQCCProbeAuthData
+    ) -> IQCCProbeAuthResponse:
+        response = await cls._call_task_pydantic(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.IQCC_PROBE_AUTH_FULL_PATH}",
+            model=data,
+        )
+        return IQCCProbeAuthResponse.parse_obj(response)

classiq/_internals/authentication/auth0.py

@@ -3,18 +3,34 @@ from dataclasses import dataclass
 from typing import Any, Dict, Optional, Union
 
 from httpx import AsyncClient, Response, codes
-from pydantic import BaseSettings, Field
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from classiq.interface.exceptions import ClassiqAuthenticationError
 
 
 class AuthSettings(BaseSettings):
-    domain: str = Field(default="auth.classiq.io", env="CLASSIQ_AUTH_DOMAIN")
-    audience: str = Field(default="https://cadmium-be", env="CLASSIQ_AUTH_AUDIENCE")
+    domain: str = Field(
+        default="auth.classiq.io", validation_alias="CLASSIQ_AUTH_DOMAIN"
+    )
+    audience: str = Field(
+        default="https://cadmium-be", validation_alias="CLASSIQ_AUTH_AUDIENCE"
+    )
     client_id: str = Field(
-        default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y", env="CLASSIQ_AUTH_CLIENT_ID"
+        default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y",
+        validation_alias="CLASSIQ_AUTH_CLIENT_ID",
     )
 
+    model_config = SettingsConfigDict(extra="allow")
+
+    def __init__(self, **data: Any) -> None:
+        initial_data = {
+            field: data[field] for field in data if field in self.model_fields
+        }
+        super().__init__(**data)
+        for field, value in initial_data.items():
+            setattr(self, field, value)
+
 
 @dataclass
 class Tokens:

classiq/_internals/authentication/password_manager.py

@@ -5,23 +5,35 @@ import os
 import pathlib
 import platform
 import stat
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import keyring
 from keyring.backends import fail
-from pydantic import BaseSettings, Field
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 _logger = logging.getLogger(__name__)
 
 
 class PasswordManagerSettings(BaseSettings):
     ACCESS_TOKEN_KEY: str = Field(
-        default="classiqTokenAccount", env="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
+        default="classiqTokenAccount", validation_alias="CLASSIQ_ACCESS_TOKEN_ACCOUNT"
     )
     REFRESH_TOKEN_KEY: str = Field(
-        default="classiqRefershTokenAccount", env="CLASSIQ_REFRESH_TOKEN_ACCOUNT"
+        default="classiqRefershTokenAccount",
+        validation_alias="CLASSIQ_REFRESH_TOKEN_ACCOUNT",
     )
 
+    model_config = SettingsConfigDict(extra="allow")
+
+    def __init__(self, **data: Any) -> None:
+        initial_data = {
+            field: data[field] for field in data if field in self.model_fields
+        }
+        super().__init__(**data)
+        for field, value in initial_data.items():
+            setattr(self, field, value)
+
 
 class PasswordManager(abc.ABC):
     _SERVICE_NAME: str = "classiqTokenService"

classiq/_internals/client.py

@@ -207,7 +207,7 @@ class Client:
 
     def _make_client_args(self) -> Dict[str, Any]:
         return {
-            "base_url": self._config.host,
+            "base_url": str(self._config.host),
             "timeout": self._HTTP_TIMEOUT_SECONDS,
             "headers": self.get_headers(),
         }
@@ -269,7 +269,7 @@ class Client:
         await self._token_manager.update_expired_access_token()
 
     def get_backend_uri(self) -> str:
-        return self._config.host
+        return self._config.host.unicode_string()
 
     def check_host(self) -> None:
         # This function is NOT async (despite the fact that it can be) because it's called from a non-async context.

classiq/_internals/host_checker.py

@@ -39,7 +39,7 @@ class HostChecker:
         self._interface_version = interface_version
 
     def _get_interface_version(self) -> Optional[str]:
-        global_interfaces = GlobalVersions.parse_obj(
+        global_interfaces = GlobalVersions.model_validate(
             self._client.sync_call_api(
                 "get", "/interface_versions", use_versioned_url=False
             )
@@ -47,11 +47,13 @@ class HostChecker:
         return global_interfaces.deployed.get(self._interface_version, None)
 
     def _get_host_version(self) -> str:
-        host = HostVersions.parse_obj(self._client.sync_call_api("get", "/versions"))
+        host = HostVersions.model_validate(
+            self._client.sync_call_api("get", "/versions")
+        )
         return host.classiq_interface
 
     def _get_deprecation_info(self) -> Optional[DeprecationInfo]:
-        global_versions = GlobalVersions.parse_obj(
+        global_versions = GlobalVersions.model_validate(
             self._client.sync_call_api("get", "/versions", use_versioned_url=False)
         )
         return global_versions.deprecated.get(self._client_version, None)

classiq/_internals/jobs.py

@@ -37,7 +37,7 @@ def _join_url_path(*parts: str) -> str:
 def _general_job_description_parser(
     json_response: JSONObject,
 ) -> Optional[GeneralJobDescription]:
-    job_description = GeneralJobDescription.parse_obj(json_response)
+    job_description = GeneralJobDescription.model_validate(json_response)
     if job_description.status.is_final():
         return job_description
     return None
@@ -68,7 +68,7 @@ class JobPoller:
         self._mode = client_instance.config.mode
 
     def _parse_job_id_response(self, response: httpx.Response) -> JobID:
-        return JobID.parse_obj(response.json())
+        return JobID.model_validate(response.json())
 
     def _make_poll_url(self, job_id: JobID) -> str:
         return _join_url_path(self._base_url, job_id.job_id)
@@ -171,5 +171,5 @@ class JobPoller:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex and UUID,
         # while pydantic does. We should add support for smarter json serialization.
-        body = json.loads(model.json())
+        body = json.loads(model.model_dump_json())
         return await self.run(body, timeout_sec)

classiq/analyzer/analyzer_utilities.py

@@ -41,7 +41,7 @@ class AnalyzerUtilities:
             qubit_count=self.circuit.data.width, providers=requested_providers
         )
         result = await ApiWrapper.call_available_devices_task(params=params)
-        self.available_devices.update(result.devices.dict())
+        self.available_devices.update(result.devices.model_dump())
 
     async def request_hardware_connectivity_async(
         self, provider: ProviderNameEnum, device: DeviceName

classiq/applications/chemistry/ground_state_problem.py

@@ -33,7 +33,7 @@ async def update_problem_async(
 ) -> CHEMISTRY_PROBLEMS_TYPE:
     if num_qubits is None:
         num_qubits = await _get_num_qubits(problem)
-    return problem.copy(update={"num_qubits": num_qubits})
+    return problem.model_copy(update={"num_qubits": num_qubits})
 
 
 ground_state_problem.GroundStateProblem.update_problem = async_utils.syncify_function(  # type: ignore[attr-defined]

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -143,7 +143,9 @@ def convert_pyomo_to_global_presentation(
     pyo_model: pyo.ConcreteModel,
 ) -> pyo.ConcreteModel:
     pyo_model_str = pyomo2qmod("nativePyoModel", pyo_model)
-    problem_struct = CombinatorialOptimizationStructDeclaration.parse_raw(pyo_model_str)
+    problem_struct = CombinatorialOptimizationStructDeclaration.model_validate_json(
+        pyo_model_str
+    )
 
     pyomo_model = pyo.ConcreteModel()
 

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -23,7 +23,7 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = QuantumProgram.parse_raw(quantum_program)
+        circuit = QuantumProgram.model_validate_json(quantum_program)
         validate_circuit(circuit)
         self._quantum_program = quantum_program
         self._parameters_names = extract_parameters(circuit)

classiq/applications/qnn/qlayer.py

@@ -52,7 +52,7 @@ class QLayerFunction(torch.autograd.Function):
                 and returning a `Tensor`
 
         """
-        circuit = Circuit.parse_raw(quantum_program)
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         # save for backward
@@ -144,7 +144,7 @@ class QLayer(nn.Module):
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
     ) -> None:
-        circuit = Circuit.parse_raw(quantum_program)
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         super().__init__()

classiq/execution/__init__.py

@@ -10,6 +10,7 @@ from ..interface.executor.iqae_result import IQAEResult
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
+from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
 from .qnn import execute_qnn
 
@@ -26,6 +27,8 @@ __all__ = (
         "get_execution_jobs_async",
         "ExecutionSession",
         "execute_qnn",
+        "generate_iqcc_token",
+        "generate_iqcc_token_async",
     ]
 )
 

classiq/execution/execution_session.py

@@ -48,7 +48,7 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     return (
         program
         if isinstance(program, QuantumProgram)
-        else QuantumProgram.parse_obj(json.loads(program))
+        else QuantumProgram.model_validate(json.loads(program))
     )
 
 
@@ -162,7 +162,7 @@ class ExecutionSession:
         Returns:
             SerializedQuantumProgram: The serialized quantum program (str). See `QuantumProgram`.
         """
-        return SerializedQuantumProgram(self.program.json(indent=2))
+        return SerializedQuantumProgram(self.program.model_dump_json(indent=2))
 
     def update_execution_preferences(
         self, execution_preferences: Optional[ExecutionPreferences]

classiq/execution/iqcc.py

@@ -0,0 +1,63 @@
+import time
+import webbrowser
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.execution.iqcc import IQCCInitAuthData, IQCCProbeAuthData
+
+from classiq._internals.api_wrapper import ApiWrapper
+from classiq._internals.async_utils import syncify_function
+
+
+async def generate_iqcc_token_async(
+    auth_scope_id: str,
+    auth_method_id: str,
+    timeout: float = 120,
+    probe_interval: float = 1,
+    print_auth_url: bool = True,
+) -> str:
+    """Interactively generate a token for use in IQCC backends.
+
+    Args:
+        auth_scope_id: The ID of the IQCC Boundary authentication scope.
+        auth_method_id: The ID of the IQCC Boundary authentication method.
+        timeout: Number of seconds to wait for the interactive authentication to complete.
+        probe_interval: Number of seconds to wait between probes of the authentication.
+        print_auth_url: Whether to print the authentication URL, useful for headless machines with no browser.
+
+    Returns:
+        The authentication token string to use directly in `IQCCBackendPreferences`.
+
+    Raises:
+        ClassiqError: In case timeout has reached before a successful authentication.
+    """
+    initiate_response = await ApiWrapper().call_iqcc_init_auth(
+        IQCCInitAuthData(auth_scope_id=auth_scope_id, auth_method_id=auth_method_id)
+    )
+
+    if print_auth_url:
+        print("Please proceed with authentication on your web browser.")  # noqa: T201
+        print("If no window has opened, use this link to authenticate:")  # noqa: T201
+        print(initiate_response.auth_url)  # noqa: T201
+
+    webbrowser.open_new_tab(initiate_response.auth_url)
+
+    start_time = time.monotonic()
+    while True:
+        time.sleep(probe_interval)
+        probe_response = await ApiWrapper().call_iqcc_probe_auth(
+            IQCCProbeAuthData(
+                auth_scope_id=auth_scope_id,
+                auth_method_id=auth_method_id,
+                token_id=initiate_response.token_id,
+            )
+        )
+        if probe_response.auth_token is not None:
+            return probe_response.auth_token
+
+        if time.monotonic() - start_time > timeout:
+            raise ClassiqError(
+                f"Timeout has reached while probing IQCC authentication. Please try again and make sure to authenticate within {timeout} seconds, or increase the timeout."
+            )
+
+
+generate_iqcc_token = syncify_function(generate_iqcc_token_async)

classiq/execution/jobs.py

@@ -226,7 +226,7 @@ class ExecutionJob:
 
     async def _poll_job(self, timeout_sec: Optional[float] = None) -> None:
         def response_parser(json_response: JSONObject) -> Optional[bool]:
-            self._details = ExecutionJobDetails.parse_obj(json_response)
+            self._details = ExecutionJobDetails.model_validate(json_response)
             if self.status.is_final():
                 return True
             return None
@@ -262,7 +262,7 @@ class ExecutionJob:
 
     @property
     def ide_url(self) -> str:
-        base_url = client().config.ide
+        base_url = client().config.ide.unicode_string()
         return urljoin(base_url, f"jobs/{self.id}")
 
     def open_in_ide(self) -> None:

classiq/executor.py

@@ -27,7 +27,7 @@ BackendPreferencesAndResult: TypeAlias = Tuple[
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
 ) -> QuantumProgram:
-    return QuantumProgram.parse_raw(quantum_program)
+    return QuantumProgram.model_validate_json(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
@@ -57,7 +57,7 @@ def set_quantum_program_execution_preferences(
 ) -> SerializedQuantumProgram:
     circuit = _parse_serialized_qprog(quantum_program)
     circuit.model.execution_preferences = preferences
-    return SerializedQuantumProgram(circuit.json())
+    return SerializedQuantumProgram(circuit.model_dump_json())
 
 
 __all__ = [

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.51.1'
+SEMVER_VERSION = '0.52.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Optional
 
 import numpy
 import pydantic
-from pydantic import Field, conint, constr
+from pydantic import ConfigDict, Field, StringConstraints
 from typing_extensions import Annotated
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
@@ -36,7 +36,8 @@ class HardwareListParams(pydantic.BaseModel):
     providers: List[Provider]
     from_ide: bool = Field(default=False)
 
-    @pydantic.validator("providers", always=True)
+    @pydantic.field_validator("providers")
+    @classmethod
     def set_default_providers(
         cls, providers: Optional[List[AnalyzerProviderVendor]]
     ) -> List[AnalyzerProviderVendor]:
@@ -55,8 +56,12 @@ class AnalysisOptionalDevicesParams(HardwareListParams):
 
 
 class GateNamsMapping(pydantic.BaseModel):
-    qasm_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
-    display_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
+    qasm_name: Annotated[
+        str, Annotated[str, StringConstraints(max_length=MAX_NAME_LENGTH)]
+    ]
+    display_name: Annotated[
+        str, Annotated[str, StringConstraints(max_length=MAX_NAME_LENGTH)]
+    ]
 
 
 class LatexParams(AnalysisParams):
@@ -66,7 +71,7 @@ class LatexParams(AnalysisParams):
 
 
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
-    hardware_data: Optional[SynthesisHardwareData]
+    hardware_data: Optional[SynthesisHardwareData] = None
     random_seed: int
     transpilation_option: TranspilationOption
 
@@ -91,13 +96,18 @@ class CircuitAnalysisHardwareParams(AnalysisParams):
 
 class AnalysisRBParams(pydantic.BaseModel):
     hardware: str
-    counts: List[Dict[str, Annotated[int, conint(strict=True, gt=0, le=MAX_COUNTS)]]]
-    num_clifford: List[Annotated[int, conint(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
+    counts: List[
+        Dict[
+            str, Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_COUNTS)]]
+        ]
+    ]
+    num_clifford: List[
+        Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
+    ]
 
 
 class ChemistryGenerationParams(pydantic.BaseModel):
-    class Config:
-        title = "Chemistry"
+    model_config = ConfigDict(title="Chemistry")
 
     molecule: MoleculeProblem = pydantic.Field(
         title="Molecule",

classiq/interface/analyzer/cytoscape_graph.py

@@ -17,16 +17,23 @@ 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"
     )
 
 

classiq/interface/analyzer/result.py

@@ -3,7 +3,7 @@ from uuid import UUID
 
 import pydantic
 from pydantic import Field
-from typing_extensions import Annotated
+from typing_extensions import Annotated, Self
 
 from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
 from classiq.interface.enum_utils import StrEnum
@@ -74,12 +74,13 @@ class HardwareComparisonInformation(pydantic.BaseModel):
         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`
@@ -112,7 +113,7 @@ HardwareComparisonGraphType = Annotated[
 ]
 
 _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
-    s.upper(): s.capitalize() for s in SingleHardwareInformation.__fields__
+    s.upper(): s.capitalize() for s in SingleHardwareInformation.model_fields
 }