feat(client): wip models

Author: vmscw

README.md

@@ -12,69 +12,39 @@ pip install scaleway-qaas-client
 
 ## Getting started
 
-To instantiate the ScalewayProvider, you need to have an access token and a project_id
+To use QaaS client, you need to have an access secret_key and a Scaleway's project_id
+
 
 ```python
-from qiskit import QuantumCircuit
-from qiskit_scaleway import ScalewayProvider
+from scaleway_qaas_client import QaaSClient
 
-provider = ScalewayProvider(
-    project_id="<your-scaleway-project-id>",
-    secret_key="<your-scaleway-secret-key>",
+client = QaaSClient(
+    project_id=os.environ["SCALEWAY_PROJECT_ID"],
+    secret_key=os.environ["SCALEWAY_API_TOKEN"],
 )
-```
 
-Alternatively, the Scaleway Provider can discover your access token from environment variables or from your .env file
+platforms = client.list_platforms(name="aer_simulation_pop_c16m128")
 
-```
-export QISKIT_SCALEWAY_PROJECT_ID="project_id"
-export QISKIT_SCALEWAY_API_TOKEN="token"
-```
+assert platforms is not None
+assert len(platforms) == 1
 
-Then you can instantiate the provider without any arguments:
+target_platform = platforms[0]
 
-```python
-from qiskit import QuantumCircuit
-from qiskit_scaleway import ScalewayProvider
+assert target_platform.id is not None
 
-provider = ScalewayProvider()
-```
+session = client.create_session(platform_id=target_platform.id, max_duration="2min", max_idle_duration="2min")
 
-Now you can have acces to the supported backends:
+assert session is not None
+assert session.id is not None
+assert session.platform_id == target_platform.id
 
+while session.status == "starting":
+    session = client.get_session(session.id)
+    time.sleep(3)
 
-```python
-# List all operational backends
-backends = provider.backends(operational=True)
-print(backends)
-
-# List all backends with a minimum number of qbits
-backends = provider.backends(min_num_qubits=35)
-print(backends)
-
-# Retrieve a backend by providing search criteria. The search must have a single match
-backend = provider.get_backend("aer_simulation_h100")
-```
-
-Define a quantum circuit and run it
-
-```python
-# Define a quantum circuit that produces a 4-qubit GHZ state.
-qc = QuantumCircuit(4)
-qc.h(0)
-qc.cx(0, 1)
-qc.cx(0, 2)
-qc.cx(0, 3)
-qc.measure_all()
-
-# Create and send a job to a new QPU's session (or on an existing one)
-result = backend.run(qc, method="statevector", shots=1000).result()
-
-if result.success:
-    print(result.get_counts())
-else:
-    print(result.to_dict()["error"])
+assert session.status == "running"
 
+client.delete_session(session.id)
 ```
 
 ## Development

scaleway_qaas_client/client.py

@@ -1,6 +1,7 @@
 import json
+import randomname
 
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Union
 
 from quantum_as_a_service_api_client.models import (
     CreateJobBody,
@@ -14,25 +15,28 @@
 )
 
 from quantum_as_a_service_api_client.api.sessions.create_session import (
-    sync as create_session_sync,
+    sync as _create_session_sync,
+)
+from quantum_as_a_service_api_client.api.sessions.get_session import (
+    sync as _get_session_sync,
 )
 from quantum_as_a_service_api_client.api.sessions.terminate_session import (
-    sync as terminate_session_sync,
+    sync as _terminate_session_sync,
 )
 from quantum_as_a_service_api_client.api.sessions.delete_session import (
-    sync_detailed as delete_session_sync,
+    sync_detailed as _delete_session_sync,
 )
 from quantum_as_a_service_api_client.api.platforms.list_platforms import (
-    sync as list_platforms_sync,
+    sync as _list_platforms_sync,
 )
 from quantum_as_a_service_api_client.api.jobs.create_job import (
-    sync as create_job_sync,
+    sync as _create_job_sync,
 )
 from quantum_as_a_service_api_client.api.jobs.get_job import (
-    sync as get_job_sync,
+    sync as _get_job_sync,
 )
 from quantum_as_a_service_api_client.api.jobs.list_job_results import (
-    sync as list_job_result_sync,
+    sync as _list_job_result_sync,
 )
 
 from quantum_as_a_service_api_client.client import Client
@@ -42,33 +46,34 @@
 
 
 class QaaSClient:
-    def __init__(self, project_id: str, token: str, url: str = __DEFAULT_URL):
-        self.__token = token
+    def __init__(self, project_id: str, secret_key: str, url: str = __DEFAULT_URL):
         self.__project_id = project_id
 
         self.__client = Client(
-            headers={"X-Auth-Token": self.__token},
-            base_url=self.__url,
+            headers={"X-Auth-Token": secret_key},
+            base_url=url,
             timeout=10.0,
             verify_ssl="https" in url,
         )
 
     def list_platforms(self, name: Optional[str]) -> List[ScalewayQaasV1Alpha1Platform]:
-        response = list_platforms_sync(client=self.__client, name=name)
+        response = _list_platforms_sync(client=self.__client, name=name)
 
         assert response
 
         return response.platforms
 
     def create_session(
         self,
-        name: str,
         platform_id: str,
-        deduplication_id: str,
         max_duration: str,
         max_idle_duration: str,
+        deduplication_id: Optional[str] = None,
+        name: Optional[str] = None,
     ) -> ScalewayQaasV1Alpha1Session:
-        session = create_session_sync(
+        name = name if name else f"qs-{randomname.get_name()}"
+
+        session = _create_session_sync(
             client=self.__client,
             body=CreateSessionBody(
                 project_id=self.__project_id,
@@ -82,8 +87,13 @@ def create_session(
 
         return session
 
+    def get_session(self, session_id: str) -> ScalewayQaasV1Alpha1Session:
+        session = _get_session_sync(client=self.__client, session_id=session_id)
+
+        return session
+
     def terminate_session(self, session_id: str) -> ScalewayQaasV1Alpha1Session:
-        session = terminate_session_sync(
+        session = _terminate_session_sync(
             client=self.__client,
             body=TerminateSessionBody(
                 session_id=session_id,
@@ -93,30 +103,34 @@ def terminate_session(self, session_id: str) -> ScalewayQaasV1Alpha1Session:
         return session
 
     def delete_session(self, session_id: str):
-        delete_session_sync(client=self.__client, session_id=session_id)
+        _delete_session_sync(client=self.__client, session_id=session_id)
 
     def create_job(
-        self, name: str, session_id: str, circuits: Dict
+        self,
+        session_id: str,
+        payload: Union[Dict, List, str],
+        name: Optional[str] = None,
     ) -> ScalewayQaasV1Alpha1Job:
-        circuits = circuits if isinstance(circuits, str) else json.dumps(circuits)
+        payload = payload if isinstance(payload, str) else json.dumps(payload)
+        name = name if name else f"qj-{randomname.get_name()}"
 
-        job = create_job_sync(
+        job = _create_job_sync(
             client=self.__client,
             body=CreateJobBody(
                 name=name,
                 session_id=session_id,
-                circuit=CreateJobBodyCircuit(qiskit_circuit=circuits),
+                circuit=CreateJobBodyCircuit(qiskit_circuit=payload),
             ),
         )
 
         return job
 
     def get_job(self, job_id: str) -> ScalewayQaasV1Alpha1Job:
-        job = get_job_sync(client=self.__client, job_id=job_id)
+        job = _get_job_sync(client=self.__client, job_id=job_id)
 
         return job
 
     def list_job_results(self, job_id: str) -> List[ScalewayQaasV1Alpha1JobResult]:
-        response = list_job_result_sync(client=self.__client, job_id=job_id)
+        response = _list_job_result_sync(client=self.__client, job_id=job_id)
 
         return response.job_results

scaleway_qaas_client/models.py

@@ -12,51 +12,50 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from enum import Enum
-from typing import List
+from typing import List, Dict
 
 from dataclasses import dataclass
 from dataclasses_json import dataclass_json
 
 
 class SerializationType(Enum):
-    UNKOWN = 0
+    UNKOWN_SERIALIZATION = 0
     QASM_V1 = 1
     QASM_V2 = 2
     QASM_V3 = 3
-    JSON = 4
 
 
 @dataclass_json
 @dataclass
-class CircuitPayload:
+class CircuitData:
     serialization_type: SerializationType
     circuit_serialization: str
 
 
 @dataclass_json
 @dataclass
-class RunPayload:
-    circuits: List[CircuitPayload]
-    options: dict
+class RunData:
+    circuits: List[CircuitData]
+    options: Dict
 
 
 @dataclass_json
 @dataclass
-class BackendPayload:
+class BackendData:
     name: str
     version: str
-    options: dict
+    options: Dict
 
 
 @dataclass_json
 @dataclass
-class ClientPayload:
+class ClientData:
     user_agent: str
 
 
 @dataclass_json
 @dataclass
-class JobPayload:
-    client: ClientPayload
-    backend: BackendPayload
-    run: RunPayload
+class JobData:
+    client: ClientData
+    backend: BackendData
+    run: RunData