eqc-models 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/regressor.py

@@ -45,6 +45,12 @@ class LinearRegression(RegressorBase):
 
     num_samples: Number of samples used by Dirac-3; default: 1.
 
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+
+    port: Port number of the device when direct access is used; default: None.
+    
     l2_reg_coef: L2 regularization penalty multiplier; default: 0.
 
     alpha: A penalty multiplier to ensure the correct sign of a
@@ -72,13 +78,21 @@ class LinearRegression(RegressorBase):
         self,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,            
         l2_reg_coef=0,
         alpha=0,
     ):
         super(LinearRegression).__init__()
 
+        assert solver_access in ["cloud", "direct"]
+        
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port        
         self.l2_reg_coef = l2_reg_coef
         self.alpha = alpha
         self.params = None

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/regressorbase.py

@@ -11,19 +11,27 @@ import numpy as np
 
 from eqc_models import QuadraticModel
 from eqc_models.solvers.qciclient import Dirac3CloudSolver
-
+from eqc_models.solvers.eqcdirect import Dirac3DirectSolver
 
 class RegressorBase(QuadraticModel):
     def __init__(
         self,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,            
     ):
 
         super(self).__init__(None, None, None)
+
+        assert solver_access in ["cloud", "direct"]
         
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port        
         self.params = None
 
     def predict(self, X: np.array):
@@ -51,18 +59,28 @@ class RegressorBase(QuadraticModel):
         return
 
     def solve(self):
-        solver = Dirac3CloudSolver()
+        if self.solver_access == "direct":
+            solver = Dirac3DirectSolver()
+            solver.connect(self.ip_addr, self.port)
+        else:
+            solver = Dirac3CloudSolver()
+            
         response = solver.solve(
             self,
             sum_constraint=self._sum_constraint,
             relaxation_schedule=self.relaxation_schedule,
-            solution_precision=1,
             num_samples=self.num_samples,
         )
 
-        min_id = np.argmin(response["results"]["energies"])
-
-        sol = response["results"]["solutions"][min_id]
+        if self.solver_access == "cloud":
+            energies = response["results"]["energies"]
+            solutions = response["results"]["solutions"]
+        elif self.solver_access == "direct":
+            energies = response["energy"]
+            solutions = response["solution"]
+            
+        min_id = np.argmin(energies)
+        sol = solutions[min_id]
 
         print(response)
         

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/reservoir.py

@@ -1,5 +1,20 @@
-import numpy as np
-from emucore_direct.client import EmuCoreClient
+# (C) Quantum Computing Inc., 2025.
+import logging
+
+try:
+    from emucore_direct.client import EmuCoreClient
+except ModuleNotFoundError:
+    # Only warn here to try to disrupt package behavior as least as possible.
+    logging.warning("emucore-direct package not available")
+
+    class EmuCoreClient:
+        """This is a stub for unsupported EmuCoreClient."""
+
+        def __init__(*_, **__) -> None:
+            """Raise exception when client cannot be created."""
+            raise ModuleNotFoundError(
+                "emucore-direct package not available, likely because Python version is 3.11+"
+            )
 
 # Parameters
 VBIAS = 0.31

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/solvers/__init__.py

@@ -2,7 +2,15 @@
 from .eqcdirect import Dirac3DirectSolver
 from .qciclient import (Dirac1CloudSolver, Dirac3CloudSolver, QciClientSolver,
                         Dirac3IntegerCloudSolver, Dirac3ContinuousCloudSolver)
+from .mip import MIPMixin
+
+class Dirac3MIPCloudSolver(MIPMixin, Dirac3ContinuousCloudSolver):
+    pass
+
+class Dirac3MIPDirectSolver(MIPMixin, Dirac3DirectSolver):
+    pass
 
 __all__ = ["Dirac3DirectSolver", "Dirac1CloudSolver", "Dirac3CloudSolver", 
            "EqcDirectSolver", "QciClientSolver", "Dirac3IntegerCloudSolver",
-           "Dirac3ContinuousCloudSolver"]
+           "Dirac3ContinuousCloudSolver", "MILPMixin",
+           "Dirac3MIPCloudSolver", "Dirac3MIPDirectSolver"]

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/solvers/eqcdirect.py

@@ -1,8 +1,23 @@
 # (C) Quantum Computing Inc., 2025.
 import logging
-import numpy as np
-from eqc_direct.client import EqcClient
-from eqc_models.base.base import ModelSolver
+from typing import Dict
+
+try:
+    from eqc_direct.client import EqcClient
+except ModuleNotFoundError:
+    # Only warn here to try to disrupt package behavior as least as possible.
+    logging.warning("eqc-direct package not available")
+
+    class EqcClient:
+        """This is a stub for unsupported EqcClient."""
+
+        def __init__(*_, **__) -> None:
+            """Raise exception when client cannot be created."""
+            raise ModuleNotFoundError(
+                "eqc-direct package not available, likely because Python version is 3.11+"
+            )
+
+from eqc_models.base.base import EqcModel, ModelSolver
 from eqc_models.base.results import SolutionResults
 
 log = logging.getLogger(name=__name__)
@@ -19,7 +34,6 @@ class Dirac3DirectSolver(ModelSolver):
         sum_constraint,
         relaxation_schedule=1,
         num_samples=1,
-        solution_precision=None,
         mean_photon_number=None,
         quantum_fluctuation_coefficient=None,
     ):
@@ -30,7 +44,8 @@ class Dirac3DirectSolver(ModelSolver):
         for i in range(len(indices)):
             if max(indices[i]) > num_variables:
                 num_variables = max(indices[i])
-
+        # add machine slacks
+        num_variables += model.machine_slacks
         print("Num variables:", num_variables)
 
         client = self.client
@@ -49,7 +64,6 @@ class Dirac3DirectSolver(ModelSolver):
                 lock_id=lock_id,
                 relaxation_schedule=relaxation_schedule,
                 sum_constraint=sum_constraint,
-                solution_precision=solution_precision,
                 mean_photon_number=mean_photon_number,
                 quantum_fluctuation_coefficient=quantum_fluctuation_coefficient,
             )
@@ -68,4 +82,11 @@ class Dirac3DirectSolver(ModelSolver):
 
     @property
     def client(self) -> EqcClient:
+        """Return a new client from eqc-direct based on class config."""
+
         return EqcClient(self.ip_addr, self.port, cert_file=self.cert_file)
+
+    def makeResults(self, model : EqcModel, response : Dict):
+        """ Builds the results object """
+
+        return SolutionResults.from_eqcdirect_response(model, response, self)

eqc_models-0.14.0.data/platlib/eqc_models/solvers/mip.py

@@ -0,0 +1,115 @@
+import logging
+import numpy as np
+from eqc_models.base.base import EqcModel
+from eqc_models.base.binaries import make_binary_penalty
+from eqc_models.base.polynomial import PolynomialModel
+
+log = logging.getLogger(name=__name__)
+
+class MIPMixin:
+    """
+    Implements a solve method which intercepts the operator and builds a new
+    model with added terms for restriction of discrete variables with an 
+    upper bound of 1 to take on only values 0 or 1 at minima.
+
+    Following the submission of a new model with the added penalties,
+    the solutions are updated to exclude added slack variables.
+
+    This is only supported with continuous-capable devices.
+
+    """
+
+    def solve(self, model : EqcModel, *args, **kwargs):
+        if model.is_discrete is None:
+            raise ValueError("Model solved with an MIP solver must have certain variables labeled discrete")
+        elif len([b for b in model.is_discrete if b])==0:
+            raise ValueError("Model solved with an MIP solver must have certain variables labeled discrete")
+        if kwargs.get("sum_constraint", None) is None:
+            raise ValueError("sum_constraint must be specified for MIP model sampling")
+        # get a polynomial
+        poly = model.polynomial
+        if hasattr(poly.coefficients, "tolist"):
+            coefficients = poly.coefficients.tolist()
+        else:
+            coefficients = list(poly.coefficients)
+        indices = poly.indices
+        old_n = model.n
+        log.debug("Model coefficients %d", len(coefficients))
+        log.debug("Model indices %d", len(indices))
+        log.debug("Model size %d", old_n)
+        if "penalty_multiplier" in kwargs:
+            penalty_multiplier = kwargs["penalty_multiplier"]
+            del kwargs["penalty_multiplier"]
+        else:
+            penalty_multiplier = getattr(model, "penalty_multiplier", 1)
+        log.debug("Binary enforcement penalty multiplier %f", penalty_multiplier)
+        bin_slacks = []
+        offset = 0
+        variables = model.variables
+        addtl_upper_bound = []
+        for i, v in enumerate(model.variables):
+            if model.is_discrete[i]:
+                bin_slacks.append(f"bin_slacks_{v}")
+                penalty_coeff, penalty_indices, penalty_offset = make_binary_penalty(i+1, len(variables)+len(bin_slacks), penalty_multiplier=penalty_multiplier)
+                log.debug("Adding penalties coeff: %s indices %s offset %s", penalty_coeff, penalty_indices, penalty_offset)
+                coefficients += penalty_coeff
+                indices += penalty_indices
+                offset += penalty_offset
+                addtl_upper_bound.append(1)
+                assert len(coefficients) == len(indices)
+        variables = variables + bin_slacks
+        log.debug("New model binary penalty slacks: %s", bin_slacks)
+        new_model = PolynomialModel(coefficients, indices)
+        new_model.variables = variables
+        log.debug("New model variables: %s", variables)
+        new_model.upper_bound = np.array(model.upper_bound.tolist() + addtl_upper_bound)
+        new_model.machine_slacks = model.machine_slacks
+        coefficients, indices = new_model.H
+        log.debug("New model coefficients %d", len(coefficients))
+        log.debug("New model indices %d", len(indices))
+        log.debug("New model size: %d", new_model.n)
+        response = super().solve(new_model, *args, **kwargs)
+        # translate the response into results
+        results = self.makeResults(new_model, response)
+        log.debug(results)
+        # update the results to relect the original model
+        solutions = results.solutions
+        for i in range(len(solutions)):
+            log.debug("SolutionResults solution: %s", solutions[i])
+        if hasattr(model, "evaluateObjective"):
+            new_objectives = []
+        else:
+            new_objectives = None
+        if hasattr(model, "evaluatePenalties"):
+            new_penalties = []
+        else:
+            new_penalties = None
+        new_solutions = []
+        new_energies = []
+        num_vars = len(solutions[0]) - len(bin_slacks)
+        log.debug("Num_vars %f", num_vars)
+        machine_slacks = model.machine_slacks
+        for i, solution in enumerate(solutions):
+            log.debug("%d - Raw solution %s", i, solution)
+            new_sol = [v for v in solution[:num_vars]]
+            new_sol = np.array(new_sol)
+            if machine_slacks > 0:
+                new_sol[-machine_slacks:] = solution[-machine_slacks:]
+            log.debug("%d - New solution %s", i, new_sol)
+            if new_objectives is not None:
+                try:
+                    new_objectives.append(model.evaluateObjective(new_sol))
+                except NotImplementedError as err:
+                    pass
+            if new_penalties is not None:
+                try:
+                    new_penalties.append(model.evaluatePenalties(new_sol))
+                except NotImplementedError as err:
+                    pass
+            new_solutions.append(new_sol)
+            new_energies.append(model.evaluate(new_sol))
+        results.solutions = new_solutions
+        results.penalties = new_penalties
+        results.objectives = new_objectives
+        results.energies = new_energies
+        return results

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/solvers/qciclient.py

@@ -6,6 +6,7 @@ import numpy as np
 from qci_client import QciClient
 from eqc_models.base.base import ModelSolver, EqcModel
 from eqc_models.base.operators import OperatorNotAvailableError
+from eqc_models.base.results import SolutionResults
 
 log = logging.getLogger(name=__name__)
 
@@ -77,6 +78,11 @@ class QciClientMixin:
         metrics = client.get_job_metrics(job_id=job_id)
         return metrics
 
+    def makeResults(self, model : EqcModel, response : Dict) -> SolutionResults:
+        """ Build the results object """
+
+        return SolutionResults.from_cloud_response(model, response, self)
+
 class Dirac1Mixin:
     sampler_type = "dirac-1"
     requires_operator = "qubo"
@@ -125,7 +131,6 @@ class Dirac3Mixin:
     max_upper_bound = 10000
     job_params_names = [
         "num_samples",
-        "solution_precision",
         "relaxation_schedule",
         "mean_photon_number",
         "quantum_fluctuation_coefficient",
@@ -427,10 +432,9 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
     Dirac3CloudSolver is a class that encapsulates the different calls to Qatalyst
     for Dirac-3 jobs. Currently, there are two different jobs, one for integer and
     another for continuous solutions. Calling the solve method with different arguments
-    controls which job is submitted. The continuous job requires :code:`sum_constraint`
-    and optionally takes the :code:`solution_precision` argument. The integer job
-    does not accept either of these parameters, so specifying a sum constraint forces
-    the job type to be continuous and not specifying it results in the integer job being
+    controls which job is submitted. The continuous job requires :code:`sum_constraint`.
+    The integer job does not accept this parameter, so specifying a sum constraint forces
+    the job type to be continuous, and not specifying it results in the integer job being
     called.
 
     Continuous Solver
@@ -454,8 +458,7 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
     >>> model = QuadraticModel(C, J)
     >>> model.upper_bound = np.array([1, 1]) # set the domain maximum per variable
     >>> solver = Dirac3CloudSolver()
-    >>> response = solver.solve(model, sum_constraint=1, relaxation_schedule=1,
-    ...                         solution_precision=None) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    >>> response = solver.solve(model, sum_constraint=1, relaxation_schedule=1) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
     2... submitted... COMPLETED...
     >>> response["results"]["energies"][0] <= 1.0
     True
@@ -479,7 +482,6 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
         tags: List = None,
         sum_constraint: float = None,
         relaxation_schedule: int = None,
-        solution_precision: float = None,
         num_samples: int = 1,
         wait: bool = True,
         mean_photon_number: float = None,
@@ -503,11 +505,6 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
             a predefined schedule indicator which sets parameters
             on the device to control the sampling through photon 
             measurement
-        solution_precision : float 
-            a value which, when not None, indicates the numerical
-            precision desired in the solution: 1 for integer, 0.1
-            for tenths place, 0.01 for hundreths and None for raw,
-            only used with continuous solver
         num_samples : int 
             the number of samples to take, defaults to 1
         wait : bool 
@@ -540,7 +537,6 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
             job_kwargs["relaxation_schedule"] = relaxation_schedule
             job_kwargs["mean_photon_number"] = mean_photon_number
             job_kwargs["quantum_fluctuation_coefficient"] = quantum_fluctuation_coefficient
-            job_kwargs["solution_precision"] = solution_precision
             job_type = "sample-" + self.job_type
             return super().solve(
                 model,
@@ -663,8 +659,7 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
     >>> model = QuadraticModel(C, J)
     >>> model.upper_bound = np.array([1, 1]) # set the domain maximum per variable
     >>> solver = Dirac3ContinuousCloudSolver()
-    >>> response = solver.solve(model, sum_constraint=1, relaxation_schedule=1,
-    ...                         solution_precision=None) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    >>> response = solver.solve(model, sum_constraint=1, relaxation_schedule=1) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
     2... submitted... COMPLETED...
     >>> response["results"]["energies"][0] <= 1.0
     True
@@ -680,7 +675,6 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
         tags: List = None,
         sum_constraint: float = None,
         relaxation_schedule: int = None,
-        solution_precision: float = None,
         num_samples: int = 1,
         wait: bool = True,
         mean_photon_number: float = None,
@@ -703,10 +697,6 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
             a predefined schedule indicator which sets parameters
             on the device to control the sampling through photon 
             measurement
-        solution_precision : float 
-            a value which, when not None, indicates the numerical
-            precision desired in the solution: 1 for integer, 0.1
-            for tenths place, 0.01 for hundreths and None for raw
         num_samples : int 
             the number of samples to take, defaults to 1
         wait : bool 
@@ -744,7 +734,6 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
             num_samples=num_samples,
             wait=wait,
             job_type=job_type,
-            solution_precision=solution_precision,
             sum_constraint=sum_constraint,
             relaxation_schedule=relaxation_schedule,
             mean_photon_number=mean_photon_number,

eqc_models-0.14.0.data/platlib/eqc_models/solvers/responselog.py

@@ -0,0 +1,47 @@
+import os
+import json
+import time
+
+class ResponseLogMixin:
+
+    def logResponse(self, response, model, metrics=None):
+        record = {
+            "response": response,
+            "metrics": metrics,
+            "size": model.n,
+            "name": model.__class__.__name__,
+            "upper_bound": [u for u in model.upper_bound],
+            "machine_slacks": model.machine_slacks,
+            "penalty_multiplier": getattr(model, "penalty_multiplier", None)
+           } 
+        fname = f"response-{time.time()}.json"
+        dirname = self.getLogDir()
+        fullname = os.path.join(dirname, fname)
+        if not os.access(fullname, os.W_OK):
+            log.warn(f"Response will not be logged because {fullname} is not writable")
+            return
+        elif os.path.exists(fullname):
+            log.warn(f"Response will not be logged because {fullname} exists")
+            return
+        with open(fullname, "w") as fp:
+            log.debug(f"Wrote response to {fullname}")
+            json.dump(record, fp)
+
+    def getLogDir(self):
+        """ Ensure the logging directory exists and return the path """
+
+        dirname = os.path.expanduser("~/.eqc-models")
+        if not os.path.exists(dirname):
+            try:
+                os.mkdir(dirname)
+            except OSError:
+                log.warn(f"Responses will not be logged because {dirname} is not writable")
+                return None
+        dirname = os.path.join(dirname, "responses")
+        if not os.path.exists(dirname):
+            try>
+                os.mkdir(dirname)
+            except OSError:
+                log.warn(f"Responses will not be logged because {dirname} is not writable")
+                return None
+        return dirname

{eqc_models-0.12.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/utilities/__init__.py

@@ -1,6 +1,7 @@
 # (C) Quantum Computing Inc., 2024.
 from .polynomial import evaluate_polynomial, convert_hamiltonian_to_polynomial
 from .fileio import read_coefficient_file, read_config_file, read_index_file
+from .general import create_json_problem
 
 __all__ = ["evaluate_polynomial", 
-           "read_coefficient_file", "read_index_file", "read_config_file", "convert_hamiltonian_to_polynomial"]
+           "read_coefficient_file", "read_index_file", "read_config_file", "convert_hamiltonian_to_polynomial", "create_json_problem"]

eqc_models-0.14.0.data/platlib/eqc_models/utilities/general.py

@@ -0,0 +1,83 @@
+# (C) Quantum Computing Inc., 2024.
+import numpy as np
+from eqc_models.utilities.polynomial import convert_hamiltonian_to_polynomial
+
+def create_json_problem(
+        A: np.array,
+        B: np.array,
+        C: np.array,
+        D: np.array,        
+        num_vars: int,
+        sum_constraint: float = None,
+        num_levels: int = None,
+):
+
+    """Converts a hamiltonian of up to fourth order to a polynomial.
+
+    D_{ijkl} x_i x_j x_k x_l + C_{ijk} x_i x_j x_k + B_{ij} x_i x_j
+    + A_i x_i
+
+    Input:
+
+    A: First order hamiltonian.
+    B: Second order hamiltonian.
+    C: Third order hamiltonian.
+    D: Fourth order hamiltonian.
+    num_vars: Number of variables.
+
+    Output:
+
+    Problem in json format.
+
+    """
+
+    if D is not None:
+        assert len(D.shape) == 4, "Incorrect shape!"                
+        assert D.shape[0] == num_vars, "Inconsistent dimensions!"
+        assert D.shape[1] == num_vars, "Inconsistent dimensions!"
+        assert D.shape[2] == num_vars, "Inconsistent dimensions!"
+        assert D.shape[3] == num_vars, "Inconsistent dimensions!"
+        degree = 4
+    elif C is not None:
+        assert len(C.shape) == 3, "Incorrect shape!"                
+        assert C.shape[0] == num_vars, "Inconsistent dimensions!"
+        assert C.shape[1] == num_vars, "Inconsistent dimensions!"
+        assert C.shape[2] == num_vars, "Inconsistent dimensions!"
+        degree = 3
+    elif B is not None:
+        assert len(B.shape) == 2, "Incorrect shape!"        
+        assert B.shape[0] == num_vars, "Inconsistent dimensions!"
+        assert B.shape[1] == num_vars, "Inconsistent dimensions!"
+        degree = 2
+    elif A is not None:
+        assert len(A.shape) in [1, 2], "Incorrect shape!"
+        if len(A.shape) == 2:
+            if A.shape[1] == 1:
+                A = A.reshape((A.shape[0]))
+            else:
+                assert False, "Incorrect shape!"
+        
+        assert A.shape[0] == num_vars, "Inconsistent dimensions!"
+            
+        degree = 1
+    else:
+        assert False, "No hamiltonian provided!"
+        
+    poly_indices, poly_coefs = convert_hamiltonian_to_polynomial(
+        A, B, C, D, num_vars,
+    )
+    
+    json_object = {
+        "degree": degree,
+        "num_variables": num_vars,
+        "poly_indices": poly_indices,
+        "poly_coefficients": poly_coefs,
+    }
+
+    if num_levels is not None:
+        json_object["levels"] = [num_levels] * num_vars
+
+    if sum_constraint is not None:
+        json_object["sum_constraint"] = sum_constraint
+        
+    return json_object

{eqc_models-0.12.0.dist-info → eqc_models-0.14.0.dist-info}/METADATA

@@ -1,22 +1,23 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.12.0
+Version: 0.14.0
 Summary: Optimization and ML modeling package targeting EQC devices
-Author: Quantum Computing Inc.
-Author-email: support@quantumcomputinginc.com
+Author-email: "Quantum Computing Inc." <support@quantumcomputinginc.com>
 Project-URL: Homepage, https://quantumcomputinginc.com
 Project-URL: Documentation, https://quantumcomputinginc.com/learn/support/software-packages/
 Project-URL: Issues, https://support.quantumcomputinginc.com/
-Requires-Python: <3.11,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: emucore-direct==1.0.7; python_version < "3.11"
+Requires-Dist: eqc-direct==2.0.2; python_version < "3.11"
 Requires-Dist: numpy<2,>=1.22.1
 Requires-Dist: networkx<3,>=2.6.3
-Requires-Dist: pandas>=2.1.0
-Requires-Dist: scikit-learn>=1.2.1
-Requires-Dist: qci-client<5,>=4.3.0
-Requires-Dist: emucore-direct==1.0.6
-Requires-Dist: eqc-direct<3,>=2.0.1
+Requires-Dist: pandas<3,>=2.1.0
+Requires-Dist: scikit-learn<2,>=1.2.1
+Requires-Dist: lightgbm<5,>=4.6.0
+Requires-Dist: xgboost<2,>=1.7.4
+Requires-Dist: qci-client<6,>=5
 Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"