✨ QDMI authentication via FoMaC

bindings/fomac/fomac.cpp

@@ -26,23 +26,52 @@
 using namespace py::literals;
 
 PYBIND11_MODULE(MQT_CORE_MODULE_NAME, m, py::mod_gil_not_used()) {
+  auto session = py::class_<fomac::Session>(m, "Session");
+
+  const fomac::SessionConfig defaultConfig;
+  session.def(
+      py::init(
+          [](const std::optional<std::string>& token,
+             const std::optional<std::string>& authFile,
+             const std::optional<std::string>& authUrl,
+             const std::optional<std::string>& username,
+             const std::optional<std::string>& password,
+             const std::optional<std::string>& projectId) -> fomac::Session {
+            fomac::SessionConfig config;
+            config.token = token;
+            config.authFile = authFile;
+            config.authUrl = authUrl;
+            config.username = username;
+            config.password = password;
+            config.projectId = projectId;
+            return fomac::Session{config};
+          }),
+      "token"_a = defaultConfig.token, "auth_file"_a = defaultConfig.authFile,
+      "auth_url"_a = defaultConfig.authUrl,
+      "username"_a = defaultConfig.username,
+      "password"_a = defaultConfig.password,
+      "project_id"_a = defaultConfig.projectId);
+
+  session.def("get_devices", &fomac::Session::getDevices);
+
   // Job class
-  auto job = py::class_<fomac::FoMaC::Job>(m, "Job");
-  job.def("check", &fomac::FoMaC::Job::check);
-  job.def("wait", &fomac::FoMaC::Job::wait, "timeout"_a = 0);
-  job.def("cancel", &fomac::FoMaC::Job::cancel);
-  job.def("get_shots", &fomac::FoMaC::Job::getShots);
-  job.def("get_counts", &fomac::FoMaC::Job::getCounts);
-  job.def("get_dense_statevector", &fomac::FoMaC::Job::getDenseStateVector);
-  job.def("get_dense_probabilities", &fomac::FoMaC::Job::getDenseProbabilities);
-  job.def("get_sparse_statevector", &fomac::FoMaC::Job::getSparseStateVector);
+  auto job = py::class_<fomac::Session::Job>(m, "Job");
+  job.def("check", &fomac::Session::Job::check);
+  job.def("wait", &fomac::Session::Job::wait, "timeout"_a = 0);
+  job.def("cancel", &fomac::Session::Job::cancel);
+  job.def("get_shots", &fomac::Session::Job::getShots);
+  job.def("get_counts", &fomac::Session::Job::getCounts);
+  job.def("get_dense_statevector", &fomac::Session::Job::getDenseStateVector);
+  job.def("get_dense_probabilities",
+          &fomac::Session::Job::getDenseProbabilities);
+  job.def("get_sparse_statevector", &fomac::Session::Job::getSparseStateVector);
   job.def("get_sparse_probabilities",
-          &fomac::FoMaC::Job::getSparseProbabilities);
-  job.def_property_readonly("id", &fomac::FoMaC::Job::getId);
+          &fomac::Session::Job::getSparseProbabilities);
+  job.def_property_readonly("id", &fomac::Session::Job::getId);
   job.def_property_readonly("program_format",
-                            &fomac::FoMaC::Job::getProgramFormat);
-  job.def_property_readonly("program", &fomac::FoMaC::Job::getProgram);
-  job.def_property_readonly("num_shots", &fomac::FoMaC::Job::getNumShots);
+                            &fomac::Session::Job::getProgramFormat);
+  job.def_property_readonly("program", &fomac::Session::Job::getProgram);
+  job.def_property_readonly("num_shots", &fomac::Session::Job::getNumShots);
   job.def(py::self == py::self); // NOLINT(misc-redundant-expression)
   job.def(py::self != py::self); // NOLINT(misc-redundant-expression)
 
@@ -79,7 +108,7 @@
       .export_values()
       .finalize();
 
-  auto device = py::class_<fomac::FoMaC::Device>(m, "Device");
+  auto device = py::class_<fomac::Session::Device>(m, "Device");
 
   py::native_enum<QDMI_Device_Status>(device, "Status", "enum.Enum",
                                       "Enumeration of device status.")
@@ -92,98 +121,96 @@
       .export_values()
       .finalize();
 
-  auto site = py::class_<fomac::FoMaC::Device::Site>(device, "Site");
-  site.def("index", &fomac::FoMaC::Device::Site::getIndex);
-  site.def("t1", &fomac::FoMaC::Device::Site::getT1);
-  site.def("t2", &fomac::FoMaC::Device::Site::getT2);
-  site.def("name", &fomac::FoMaC::Device::Site::getName);
-  site.def("x_coordinate", &fomac::FoMaC::Device::Site::getXCoordinate);
-  site.def("y_coordinate", &fomac::FoMaC::Device::Site::getYCoordinate);
-  site.def("z_coordinate", &fomac::FoMaC::Device::Site::getZCoordinate);
-  site.def("is_zone", &fomac::FoMaC::Device::Site::isZone);
-  site.def("x_extent", &fomac::FoMaC::Device::Site::getXExtent);
-  site.def("y_extent", &fomac::FoMaC::Device::Site::getYExtent);
-  site.def("z_extent", &fomac::FoMaC::Device::Site::getZExtent);
-  site.def("module_index", &fomac::FoMaC::Device::Site::getModuleIndex);
-  site.def("submodule_index", &fomac::FoMaC::Device::Site::getSubmoduleIndex);
-  site.def("__repr__", [](const fomac::FoMaC::Device::Site& s) {
+  auto site = py::class_<fomac::Session::Device::Site>(device, "Site");
+  site.def("index", &fomac::Session::Device::Site::getIndex);
+  site.def("t1", &fomac::Session::Device::Site::getT1);
+  site.def("t2", &fomac::Session::Device::Site::getT2);
+  site.def("name", &fomac::Session::Device::Site::getName);
+  site.def("x_coordinate", &fomac::Session::Device::Site::getXCoordinate);
+  site.def("y_coordinate", &fomac::Session::Device::Site::getYCoordinate);
+  site.def("z_coordinate", &fomac::Session::Device::Site::getZCoordinate);
+  site.def("is_zone", &fomac::Session::Device::Site::isZone);
+  site.def("x_extent", &fomac::Session::Device::Site::getXExtent);
+  site.def("y_extent", &fomac::Session::Device::Site::getYExtent);
+  site.def("z_extent", &fomac::Session::Device::Site::getZExtent);
+  site.def("module_index", &fomac::Session::Device::Site::getModuleIndex);
+  site.def("submodule_index", &fomac::Session::Device::Site::getSubmoduleIndex);
+  site.def("__repr__", [](const fomac::Session::Device::Site& s) {
     return "<Site index=" + std::to_string(s.getIndex()) + ">";
   });
   site.def(py::self == py::self); // NOLINT(misc-redundant-expression)
   site.def(py::self != py::self); // NOLINT(misc-redundant-expression)
 
   auto operation =
-      py::class_<fomac::FoMaC::Device::Operation>(device, "Operation");
-  operation.def("name", &fomac::FoMaC::Device::Operation::getName,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+      py::class_<fomac::Session::Device::Operation>(device, "Operation");
+  operation.def("name", &fomac::Session::Device::Operation::getName,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
-  operation.def("qubits_num", &fomac::FoMaC::Device::Operation::getQubitsNum,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+  operation.def("qubits_num", &fomac::Session::Device::Operation::getQubitsNum,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
   operation.def("parameters_num",
-                &fomac::FoMaC::Device::Operation::getParametersNum,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+                &fomac::Session::Device::Operation::getParametersNum,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
-  operation.def("duration", &fomac::FoMaC::Device::Operation::getDuration,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+  operation.def("duration", &fomac::Session::Device::Operation::getDuration,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
-  operation.def("fidelity", &fomac::FoMaC::Device::Operation::getFidelity,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+  operation.def("fidelity", &fomac::Session::Device::Operation::getFidelity,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
   operation.def("interaction_radius",
-                &fomac::FoMaC::Device::Operation::getInteractionRadius,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+                &fomac::Session::Device::Operation::getInteractionRadius,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
   operation.def("blocking_radius",
-                &fomac::FoMaC::Device::Operation::getBlockingRadius,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+                &fomac::Session::Device::Operation::getBlockingRadius,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
   operation.def("idling_fidelity",
-                &fomac::FoMaC::Device::Operation::getIdlingFidelity,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+                &fomac::Session::Device::Operation::getIdlingFidelity,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
-  operation.def("is_zoned", &fomac::FoMaC::Device::Operation::isZoned);
-  operation.def("sites", &fomac::FoMaC::Device::Operation::getSites);
-  operation.def("site_pairs", &fomac::FoMaC::Device::Operation::getSitePairs);
+  operation.def("is_zoned", &fomac::Session::Device::Operation::isZoned);
+  operation.def("sites", &fomac::Session::Device::Operation::getSites);
+  operation.def("site_pairs", &fomac::Session::Device::Operation::getSitePairs);
   operation.def("mean_shuttling_speed",
-                &fomac::FoMaC::Device::Operation::getMeanShuttlingSpeed,
-                "sites"_a = std::vector<fomac::FoMaC::Device::Site>{},
+                &fomac::Session::Device::Operation::getMeanShuttlingSpeed,
+                "sites"_a = std::vector<fomac::Session::Device::Site>{},
                 "params"_a = std::vector<double>{});
-  operation.def("__repr__", [](const fomac::FoMaC::Device::Operation& op) {
+  operation.def("__repr__", [](const fomac::Session::Device::Operation& op) {
     return "<Operation name=\"" + op.getName() + "\">";
   });
   operation.def(py::self == py::self); // NOLINT(misc-redundant-expression)
   operation.def(py::self != py::self); // NOLINT(misc-redundant-expression)
 
-  device.def("name", &fomac::FoMaC::Device::getName);
-  device.def("version", &fomac::FoMaC::Device::getVersion);
-  device.def("status", &fomac::FoMaC::Device::getStatus);
-  device.def("library_version", &fomac::FoMaC::Device::getLibraryVersion);
-  device.def("qubits_num", &fomac::FoMaC::Device::getQubitsNum);
-  device.def("sites", &fomac::FoMaC::Device::getSites);
-  device.def("regular_sites", &fomac::FoMaC::Device::getRegularSites);
-  device.def("zones", &fomac::FoMaC::Device::getZones);
-  device.def("operations", &fomac::FoMaC::Device::getOperations);
-  device.def("coupling_map", &fomac::FoMaC::Device::getCouplingMap);
-  device.def("needs_calibration", &fomac::FoMaC::Device::getNeedsCalibration);
-  device.def("length_unit", &fomac::FoMaC::Device::getLengthUnit);
+  device.def("name", &fomac::Session::Device::getName);
+  device.def("version", &fomac::Session::Device::getVersion);
+  device.def("status", &fomac::Session::Device::getStatus);
+  device.def("library_version", &fomac::Session::Device::getLibraryVersion);
+  device.def("qubits_num", &fomac::Session::Device::getQubitsNum);
+  device.def("sites", &fomac::Session::Device::getSites);
+  device.def("regular_sites", &fomac::Session::Device::getRegularSites);
+  device.def("zones", &fomac::Session::Device::getZones);
+  device.def("operations", &fomac::Session::Device::getOperations);
+  device.def("coupling_map", &fomac::Session::Device::getCouplingMap);
+  device.def("needs_calibration", &fomac::Session::Device::getNeedsCalibration);
+  device.def("length_unit", &fomac::Session::Device::getLengthUnit);
   device.def("length_scale_factor",
-             &fomac::FoMaC::Device::getLengthScaleFactor);
-  device.def("duration_unit", &fomac::FoMaC::Device::getDurationUnit);
+             &fomac::Session::Device::getLengthScaleFactor);
+  device.def("duration_unit", &fomac::Session::Device::getDurationUnit);
   device.def("duration_scale_factor",
-             &fomac::FoMaC::Device::getDurationScaleFactor);
-  device.def("min_atom_distance", &fomac::FoMaC::Device::getMinAtomDistance);
+             &fomac::Session::Device::getDurationScaleFactor);
+  device.def("min_atom_distance", &fomac::Session::Device::getMinAtomDistance);
   device.def("supported_program_formats",
-             &fomac::FoMaC::Device::getSupportedProgramFormats);
-  device.def("submit_job", &fomac::FoMaC::Device::submitJob, "program"_a,
+             &fomac::Session::Device::getSupportedProgramFormats);
+  device.def("submit_job", &fomac::Session::Device::submitJob, "program"_a,
              "program_format"_a, "num_shots"_a);
-  device.def("__repr__", [](const fomac::FoMaC::Device& dev) {
+  device.def("__repr__", [](const fomac::Session::Device& dev) {
     return "<Device name=\"" + dev.getName() + "\">";
   });
   device.def(py::self == py::self); // NOLINT(misc-redundant-expression)
   device.def(py::self != py::self); // NOLINT(misc-redundant-expression)
-
-  m.def("devices", &fomac::FoMaC::getDevices);
 }
 
 } // namespace mqt

bindings/na/fomac/fomac.cpp

@@ -42,7 +42,7 @@ PYBIND11_MODULE(MQT_CORE_MODULE_NAME, m, py::mod_gil_not_used()) {
   pybind11::module_::import("mqt.core.fomac");
 
   auto device =
-      py::class_<na::FoMaC::Device, fomac::FoMaC::Device>(m, "Device");
+      py::class_<na::Session::Device, fomac::Session::Device>(m, "Device");
 
   auto lattice = py::class_<na::Device::Lattice>(device, "Lattice");
 
@@ -91,22 +91,22 @@ PYBIND11_MODULE(MQT_CORE_MODULE_NAME, m, py::mod_gil_not_used()) {
   lattice.def(py::self == py::self);
   lattice.def(py::self != py::self);
 
-  device.def_property_readonly("traps", &na::FoMaC::Device::getTraps);
-  device.def_property_readonly("t1", [](const na::FoMaC::Device& dev) {
+  device.def_property_readonly("traps", &na::Session::Device::getTraps);
+  device.def_property_readonly("t1", [](const na::Session::Device& dev) {
     return dev.getDecoherenceTimes().t1;
   });
-  device.def_property_readonly("t2", [](const na::FoMaC::Device& dev) {
+  device.def_property_readonly("t2", [](const na::Session::Device& dev) {
     return dev.getDecoherenceTimes().t2;
   });
-  device.def("__repr__", [](const fomac::FoMaC::Device& dev) {
+  device.def("__repr__", [](const fomac::Session::Device& dev) {
     return "<Device name=\"" + dev.getName() + "\">";
   });
   device.def(py::self == py::self);
   device.def(py::self != py::self);
 
-  m.def("devices", &na::FoMaC::getDevices);
+  m.def("devices", &na::Session::getDevices);
   device.def_static("try_create_from_device",
-                    &na::FoMaC::Device::tryCreateFromDevice, "device"_a);
+                    &na::Session::Device::tryCreateFromDevice, "device"_a);
 }
 // NOLINTEND(misc-redundant-expression)
 } // namespace mqt