cornflow-client 2.0.0a23__tar.gz → 2.0.0rc2__tar.gz

{cornflow_client-2.0.0a23/cornflow_client.egg-info → cornflow_client-2.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cornflow-client
-Version: 2.0.0a23
+Version: 2.0.0rc2
 Summary: Client to connect to a cornflow server
 Home-page: https://github.com/baobabsoluciones/cornflow
 Author: baobab soluciones
@@ -9,16 +9,16 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: requests<=2.32.4
-Requires-Dist: genson<=1.2.2
-Requires-Dist: jsonschema<=4.21.1
-Requires-Dist: marshmallow<=3.20.2
-Requires-Dist: pytups<=0.86.2
-Requires-Dist: ortools<=9.8.3296
-Requires-Dist: PuLP<=2.9.0
+Requires-Dist: requests==2.32.4
+Requires-Dist: genson==1.2.2
+Requires-Dist: jsonschema==4.21.1
+Requires-Dist: marshmallow==3.26.2
+Requires-Dist: pytups==0.86.2
+Requires-Dist: ortools==9.8.3296
+Requires-Dist: PuLP==2.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/airflow/api.py

@@ -31,6 +31,12 @@ class Airflow(object):
 
     @classmethod
     def from_config(cls, config):
+        """
+        Create an Airflow client from a configuration dictionary.
+
+        :param config: The configuration dictionary
+        :return: The Airflow client
+        """
         data = dict(
             url=config["AIRFLOW_URL"],
             user=config["AIRFLOW_USER"],
@@ -39,6 +45,12 @@ class Airflow(object):
         return cls(**data)
 
     def is_alive(self, config=None):
+        """
+        Check if the Airflow server is alive.
+
+        :param config: The configuration dictionary
+        :return: True if the Airflow server is alive, False otherwise
+        """
         try:
             response = requests.get(f"{self.url}/health")
         except (ConnectionError, HTTPError):
@@ -55,6 +67,13 @@ class Airflow(object):
         return database and scheduler
 
     def request_headers_auth(self, status=200, **kwargs):
+        """
+        Request headers with authentication.
+
+        :param status: The status code to check
+        :param kwargs: The keyword arguments to pass to the request
+        :return: The response
+        """
         def_headers = {"Content-type": "application/json", "Accept": "application/json"}
         headers = kwargs.get("headers", def_headers)
         response = requests.request(headers=headers, auth=self.auth, **kwargs)
@@ -63,6 +82,16 @@ class Airflow(object):
         return response
 
     def consume_dag_run(self, dag_name, payload, dag_run_id=None, method="POST"):
+        """
+        Consume a DAG run.
+
+        :param dag_name: The name of the DAG
+        :param payload: The payload to pass to the request
+        :param dag_run_id: The ID of the DAG run
+        :param method: The method to use to consume the DAG run
+        :return: The response
+        """
+        # TODO: cleanup method input arguments
         url = f"{self.url}/dags/{dag_name}/dagRuns"
         if dag_run_id is not None:
             url = url + f"/{dag_run_id}"
@@ -70,6 +99,13 @@ class Airflow(object):
         return response
 
     def set_dag_run_state(self, dag_name, payload):
+        """
+        Set the state of a DAG run.
+
+        :param dag_name: The name of the DAG
+        :param payload: The payload to pass to the request
+        :return: The response
+        """
         url = f"{self.url}/dags/{dag_name}/updateTaskInstancesState"
         return self.request_headers_auth(method="POST", url=url, json=payload)
 
@@ -80,6 +116,15 @@ class Airflow(object):
         checks_only=False,
         case_id=None,
     ):
+        """
+        Run a workflow.
+
+        :param execution_id: The ID of the execution
+        :param workflow_name: The name of the DAG
+        :param checks_only: Whether to run the checks only
+        :param case_id: The ID of the case
+        :return: The response
+        """
         conf = dict(exec_id=execution_id, checks_only=checks_only)
         if case_id is not None:
             conf["case_id"] = case_id
@@ -90,10 +135,21 @@ class Airflow(object):
         self, execution_id, dag_name="solve_model_dag", checks_only=False, case_id=None
     ):
         """
-        Run workflow
+        Run workflow.
+
+        DEPRECATION: This method is deprecated and will be removed in version 2.0.0.
+
+        :param execution_id: The ID of the execution
+        :param dag_name: The name of the DAG
+        :param checks_only: Whether to run the checks only
+        :param case_id: The ID of the case
+        :return: The response
         """
         warnings.warn(
-            "This method will be deprecated on later versions, please use newer run_workflow method"
+            "This method is deprecated and will be removed in version 2.0.0 "
+            "Please use run_workflow() instead.",
+            DeprecationWarning,
+            stacklevel=2,
         )
         return self.run_workflow(
             execution_id,
@@ -103,17 +159,62 @@ class Airflow(object):
         )
 
     def update_schemas(self, dag_name="update_all_schemas"):
+        """
+        Update the schemas.
+
+        :param dag_name: The name of the DAG
+        :return: The response
+        """
         return self.consume_dag_run(dag_name, payload={}, method="POST")
 
     def update_dag_registry(self, dag_name="update_dag_registry"):
+        """
+        Update the DAG registry.
+
+        :param dag_name: The name of the DAG
+        :return: The response
+        """
         return self.consume_dag_run(dag_name, payload={}, method="POST")
 
     def get_run_status(self, schema, run_id):
+        """
+        Get the status of a DAG run.
+
+        :param schema: The name of the DAG
+        :param run_id: The ID of the DAG run
+        :return: The status of the DAG run
+        """
         return self.consume_dag_run(
             schema, payload=None, dag_run_id=run_id, method="GET"
         )
 
+    def get_dag_run_status(self, dag_name, dag_run_id):
+        """
+        Get the status of a DAG run.
+
+        DEPRECATION: This method is deprecated and will be removed in version 2.0.0.
+
+        :param dag_name: The name of the DAG
+        :param dag_run_id: The ID of the DAG run
+        :return: The status of the DAG run
+        """
+        warnings.warn(
+            "This method is deprecated and will be removed in version 2.0.0. "
+            "Please use get_run_status() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.get_run_status(dag_name, dag_run_id)
+
     def set_dag_run_to_fail(self, dag_name, run_id, new_status="failed"):
+        """
+        Set the status of a DAG run to failed.
+
+        :param dag_name: The name of the DAG
+        :param run_id: The ID of the DAG run
+        :param new_status: The new status of the DAG run
+        :return: The response
+        """
         # here, two calls have to be done:
         # first we get information on the dag_run
         dag_run = self.consume_dag_run(
@@ -135,45 +236,124 @@ class Airflow(object):
         return self.set_dag_run_state(dag_name, payload=payload)
 
     def get_all_dag_runs(self, dag_name):
+        """
+        Get all the DAG runs.
+
+        :param dag_name: The name of the DAG
+        :return: The response
+        """
         return self.consume_dag_run(dag_name=dag_name, payload=None, method="GET")
 
     def get_workflow_info(self, workflow_name, method="GET"):
+        """
+        Get the information of a DAG.
+
+        :param workflow_name: The name of the DAG
+        :param method: The method to use to get the information
+        :return: The information of the DAG
+        """
+        # TODO: cleanup method input arguments
         url = f"{self.url}/dags/{workflow_name}"
         schema_info = self.request_headers_auth(method=method, url=url)
         if schema_info.status_code != 200:
             raise AirflowError("DAG not available")
         return schema_info
 
+    def get_dag_info(self, dag_name, method="GET"):
+        """
+        Get the information of a DAG.
+
+        DEPRECATION: This method is deprecated and will be removed in version 2.0.0.
+
+        :param dag_name: The name of the DAG
+        :param method: The method to use to get the information
+        :return: The information of the DAG
+        """
+        warnings.warn(
+            "This method is deprecated and will be removed in version 2.0.0. "
+            "Please use get_workflow_info() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.get_workflow_info(dag_name, method)
+
     def get_one_variable(self, variable):
+        """
+        Get one variable.
+
+        :param variable: The name of the variable
+        :return: The variable
+        """
         url = f"{self.url}/variables/{variable}"
         return self.request_headers_auth(method="GET", url=url).json()
 
     def get_all_variables(self):
+        """
+        Get all variables.
+
+        :return: The variables
+        """
         return self.request_headers_auth(
             method="GET", url=f"{self.url}/variables"
         ).json()
 
     def get_one_schema(self, dag_name, schema):
+        """
+        Get one schema.
+
+        :param dag_name: The name of the DAG
+        :param schema: The name of the schema
+        :return: The schema
+        """
         return self.get_schemas_for_dag_name(dag_name)[schema]
 
     def get_schemas_for_dag_name(self, dag_name):
+        """
+        Get all schemas for a DAG name.
+
+        :param dag_name: The name of the DAG
+        :return: The schemas
+        """
         response = self.get_one_variable(dag_name)
         result = json.loads(response["value"])
         result["name"] = response["key"]
         return result
 
     def get_all_schemas(self):
+        """
+        Get all schemas.
+
+        :return: The schemas
+        """
         response = self.get_all_variables()
         return [dict(name=variable["key"]) for variable in response["variables"]]
 
     def get_all_dags(self, method="GET"):
+        """
+        Get all DAGs.
+
+        :param method: The method to use to get the DAGs
+        :return: The DAGs
+        """
         url = f"{self.url}/dags"
         return self.request_headers_auth(method=method, url=url)
 
     def get_internal_dags(self, method="GET"):
+        """
+        Get all internal DAGs.
+
+        :param method: The method to use to get the DAGs
+        :return: The DAGs
+        """
         url = f"{self.url}/dags?tags=internal"
         return self.request_headers_auth(method=method, url=url)
 
     def get_model_dags(self, method="GET"):
+        """
+        Get all model DAGs.
+
+        :param method: The method to use to get the DAGs
+        :return: The DAGs
+        """
         url = f"{self.url}/dags?tags=model"
         return self.request_headers_auth(method=method, url=url)

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/core/application.py

@@ -8,6 +8,7 @@ from timeit import default_timer as timer
 from typing import Type, Dict, List, Tuple, Union
 
 from jsonschema import Draft7Validator
+from cornflow_client.constants import BadSolutionChecks
 from pytups import SuperDict
 
 from cornflow_client.constants import (
@@ -263,12 +264,9 @@ class ApplicationCore(ABC):
 
         # Perform data checks only if a valid solution dict was obtained
         # and the solver implements data_checks
-        if final_sol_dict:  # Checks for non-None and non-empty dict
-            try:
-                solution_checks = algo.data_checks()
-            except AttributeError:
-                # Solver doesn't implement data_checks, which is acceptable.
-                solution_checks = None
+        # Checks for non-None and non-empty dict
+        if final_sol_dict:
+            solution_checks = algo.data_checks()
 
         return final_sol_dict, solution_checks
 

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/core/experiment.py

@@ -2,7 +2,7 @@
 Base code for the experiment template.
 """
 
-import warnings
+import logging as log
 from abc import ABC, abstractmethod
 from typing import List, Dict, Union
 
@@ -14,10 +14,11 @@ from cornflow_client.constants import (
     BadSolutionChecks,
 )
 from .instance import InstanceCore
+from .instance_solution import CheckCore
 from .solution import SolutionCore
 
 
-class ExperimentCore(ABC):
+class ExperimentCore(CheckCore, ABC):
     """
     The solver template.
     """
@@ -74,17 +75,8 @@ class ExperimentCore(ABC):
         """
         Method that executes the ExperimentCore.check() method and validates the result against the schema_checks
         """
-        try:
-            checks = self.check()
-            if checks is None:
-                checks = self.check_solution()
-        except NotImplementedError:
-            warnings.warn(
-                "The check_solution() method is deprecated. Please use check() instead. "
-                "Support for check_solution() will be removed on cornflow-client 2.0.0",
-                DeprecationWarning,
-            )
-            checks = self.check_solution()
+        # Check method always exists since it is implemented in the ExperimentCore class
+        checks = self.check()
         validator = Draft7Validator(self.schema_checks)
         if not validator.is_valid(checks):
             raise BadSolutionChecks(
@@ -118,43 +110,6 @@ class ExperimentCore(ABC):
         """
         return self.launch_all_checks()
 
-    def get_check_methods(self) -> list:
-        """
-        Finds all class methods starting with check_ and returns them in a list.
-
-        :return: A list of check methods.
-        """
-        check_methods = [
-            m
-            for m in dir(self)
-            if m.startswith("check_")
-            and callable(getattr(self, m))
-            and m != "check_schema"
-            and m != "check_solution"
-        ]
-        return check_methods
-
-    def launch_all_checks(self) -> Dict[str, Union[List, Dict]]:
-        """
-        Launch every check method and return a dict with the check method name as key
-        and the list/dict of errors / warnings as value.
-
-        It will only return those checks that return a non-empty list/dict.
-        """
-        check_methods = {m: getattr(self, m)() for m in self.get_check_methods()}
-        failed_checks = {}
-        for k, v in check_methods.items():
-            if v is None:
-                continue
-
-            try:
-                if len(v) > 0:
-                    failed_checks[k.split("check_")[1]] = v
-            except TypeError:
-                failed_checks[k.split("check_")[1]] = v
-
-        return dict(failed_checks)
-
     @property
     @abstractmethod
     def schema_checks(self) -> dict:

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/core/instance.py

@@ -1,17 +1,16 @@
-"""
-
-"""
+""" """
 
+import logging as log
 from abc import ABC, abstractmethod
 from typing import List, Dict, Union
 
 from jsonschema import Draft7Validator
 
 from cornflow_client.constants import BadInstanceChecks
-from .instance_solution import InstanceSolutionCore
+from .instance_solution import InstanceSolutionCore, CheckCore
 
 
-class InstanceCore(InstanceSolutionCore, ABC):
+class InstanceCore(InstanceSolutionCore, CheckCore, ABC):
     """
     The instance template.
     """
@@ -54,39 +53,3 @@ class InstanceCore(InstanceSolutionCore, ABC):
         the method Instance.check()
         """
         raise NotImplementedError()
-
-    def get_check_methods(self) -> list:
-        """
-        Finds all class methods starting with check_ and returns them in a list.
-
-        :return: A list of check methods.
-        """
-        check_methods = [
-            m
-            for m in dir(self)
-            if m.startswith("check_")
-            and callable(getattr(self, m))
-            and m != "check_schema"
-        ]
-        return check_methods
-
-    def launch_all_checks(self) -> Dict[str, Union[List, Dict]]:
-        """
-        Launch every check method and return a dict with the check method name as key
-        and the list/dict of errors / warnings as value.
-
-        It will only return those checks that return a non-empty list/dict.
-        """
-        check_methods = {m: getattr(self, m)() for m in self.get_check_methods()}
-        failed_checks = {}
-        for k, v in check_methods.items():
-            if v is None:
-                continue
-
-            try:
-                if len(v) > 0:
-                    failed_checks[k.split("check_")[1]] = v
-            except TypeError:
-                failed_checks[k.split("check_")[1]] = v
-
-        return dict(failed_checks)

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/core/instance_solution.py

@@ -3,7 +3,8 @@
 import json
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
-from typing import List
+from typing import List, Dict, Union
+import logging as log
 
 from genson import SchemaBuilder
 from jsonschema import Draft7Validator
@@ -431,3 +432,62 @@ class InstanceSolutionCore(ABC):
         """Returns the integer value of the hour (in number) from ts string in format 'YYYY-MM-DDTh:m:s'"""
         datetime_obj = datetime.strptime(string, DATETIME_FORMAT)
         return datetime_obj.hour
+
+
+class CheckCore:
+    def get_check_methods(self) -> list:
+        """
+        Finds all class methods starting with check_ and returns them in a list.
+
+        :return: A list of check methods.
+        """
+        check_methods = [
+            m
+            for m in dir(self)
+            if m.startswith("check_")
+            and callable(getattr(self, m))
+            and m != "check_schema"
+            and m != "check_solution"
+        ]
+        return check_methods
+
+    def launch_all_checks(self) -> Dict[str, Union[List, Dict]]:
+        """
+        Launch every check method and return a dict with the check method name as key
+        and the list/dict of errors / warnings as value.
+
+        It will only return those checks that return a non-empty list/dict.
+        If a check method raises an exception, it will be caught and a generic error
+        message will be added to the checks dictionary.
+        """
+        check_method_names = self.get_check_methods()
+        check_methods = {}
+
+        # Execute each check method and catch any exceptions
+        for method_name in check_method_names:
+            try:
+                check_methods[method_name] = getattr(self, method_name)()
+            except Exception:
+                # If a check fails, add a generic error message
+                check_methods[method_name] = [
+                    {
+                        "error_type": "Check execution error",
+                        "error_message": "The execution of the check has failed, please contact support",
+                    }
+                ]
+                log.warning(
+                    f"The execution of the check {method_name} has failed, please contact support"
+                )
+
+        failed_checks = {}
+        for k, v in check_methods.items():
+            if v is None:
+                continue
+
+            try:
+                if len(v) > 0:
+                    failed_checks[k.split("check_")[1]] = v
+            except TypeError:
+                failed_checks[k.split("check_")[1]] = v
+
+        return dict(failed_checks)

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/cornflow_client/tests/unit/test_core.py

@@ -85,6 +85,39 @@ class TestCore(TestCase):
 
         self.config = SuperDict(msg=False, timeLimit=1, solver="default", seconds=10)
 
+    @property
+    def error_check_schema(self):
+        """Common schema for error check testing used across multiple test methods."""
+        return get_empty_schema(
+            properties=dict(
+                test_check=dict(
+                    type="array",
+                    objects=dict(
+                        type="object",
+                        properties=dict(
+                            error_type=dict(type="string"),
+                            error_message=dict(type="string"),
+                        ),
+                    ),
+                ),
+                working_check=dict(
+                    type="array",
+                    objects=dict(type="object"),
+                ),
+            )
+        )
+
+    @property
+    def error_test_cases(self):
+        """Common test cases for error handling used across multiple test methods."""
+        return [
+            (RuntimeError, "Runtime error occurred"),
+            (AttributeError, "Attribute not found"),
+            (ValueError, "Invalid value provided"),
+            (TypeError, "Type mismatch error"),
+            (KeyError, "Missing key in dictionary"),
+        ]
+
     def tearDown(self):
         pass
 
@@ -293,3 +326,116 @@ class TestCore(TestCase):
                 "b_equal_c": [{"b": 2, "c": 1}],
             },
         )
+
+    def test_solution_check_method_exception_handling(self):
+        """Test that when a check_* method raises an exception, a generic error message is added."""
+
+        class DummySolution(SolutionCore):
+            schema = get_empty_schema(properties=dict(sleep=dict(type="number")))
+
+        class ErrorCheckSolver(ExperimentCore):
+            schema_checks = self.error_check_schema
+
+            def __init__(
+                self,
+                instance,
+                solution=None,
+                error_class=RuntimeError,
+                error_message="Error",
+            ):
+                super().__init__(instance, solution)
+                self.error_class = error_class
+                self.error_message = error_message
+
+            def solve(self, options):
+                self.solution = DummySolution({"sleep": 1})
+                return dict(status=STATUS_OPTIMAL, status_sol=SOLUTION_STATUS_FEASIBLE)
+
+            def check_test_check(self):
+                # Simulate different types of unexpected errors in a check method
+                raise self.error_class(self.error_message)
+
+            def check_working_check(self):
+                # This check should work correctly and return empty list (no errors)
+                return []
+
+            def get_objective(self):
+                return 0
+
+        class ErrorApp(self.app.__class__):
+            solvers = dict(default=ErrorCheckSolver)
+            solution = DummySolution
+
+        error_app = ErrorApp()
+
+        for error_class, error_message in self.error_test_cases:
+            with self.subTest(error_type=error_class.__name__):
+                # Create instance and solution for the solver
+                instance = error_app.instance.from_dict({"seconds": 1})
+                solution = error_app.solution.from_dict({"sleep": 1})
+                error_solver = ErrorCheckSolver(
+                    instance, solution, error_class, error_message
+                )
+
+                # Should NOT raise an exception, but return the checks with generic error
+                checks = error_solver.launch_all_checks()
+
+                # Verify the generic error message is in the checks for the failing check
+                self.assertIn("test_check", checks)
+                self.assertEqual(
+                    checks["test_check"],
+                    [
+                        {
+                            "error_type": "Check execution error",
+                            "error_message": "The execution of the check has failed, please contact support",
+                        }
+                    ],
+                )
+
+                # Verify that the working check is NOT in the failed checks (empty list means no errors)
+                self.assertNotIn("working_check", checks)
+
+    def test_instance_check_method_exception_handling(self):
+        """Test that when a check_* method of an instance raises an exception, a generic error message is added."""
+
+        class ErrorCheckInstance(InstanceCore):
+            schema = get_empty_schema(properties=dict(seconds=dict(type="number")))
+            schema_checks = self.error_check_schema
+
+            def __init__(self, data, error_class=RuntimeError, error_message="Error"):
+                super().__init__(data)
+                self.error_class = error_class
+                self.error_message = error_message
+
+            def check_test_check(self):
+                # Simulate different types of unexpected errors in a check method
+                raise self.error_class(self.error_message)
+
+            def check_working_check(self):
+                # This check should work correctly and return empty list (no errors)
+                return []
+
+        for error_class, error_message in self.error_test_cases:
+            with self.subTest(error_type=error_class.__name__):
+                # Create instance
+                error_instance = ErrorCheckInstance(
+                    {"seconds": 1}, error_class, error_message
+                )
+
+                # Should NOT raise an exception, but return the checks with generic error
+                checks = error_instance.launch_all_checks()
+
+                # Verify the generic error message is in the checks for the failing check
+                self.assertIn("test_check", checks)
+                self.assertEqual(
+                    checks["test_check"],
+                    [
+                        {
+                            "error_type": "Check execution error",
+                            "error_message": "The execution of the check has failed, please contact support",
+                        }
+                    ],
+                )
+
+                # Verify that the working check is NOT in the failed checks (empty list means no errors)
+                self.assertNotIn("working_check", checks)

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2/cornflow_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cornflow-client
-Version: 2.0.0a23
+Version: 2.0.0rc2
 Summary: Client to connect to a cornflow server
 Home-page: https://github.com/baobabsoluciones/cornflow
 Author: baobab soluciones
@@ -9,16 +9,16 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: requests<=2.32.4
-Requires-Dist: genson<=1.2.2
-Requires-Dist: jsonschema<=4.21.1
-Requires-Dist: marshmallow<=3.20.2
-Requires-Dist: pytups<=0.86.2
-Requires-Dist: ortools<=9.8.3296
-Requires-Dist: PuLP<=2.9.0
+Requires-Dist: requests==2.32.4
+Requires-Dist: genson==1.2.2
+Requires-Dist: jsonschema==4.21.1
+Requires-Dist: marshmallow==3.26.2
+Requires-Dist: pytups==0.86.2
+Requires-Dist: ortools==9.8.3296
+Requires-Dist: PuLP==2.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

cornflow_client-2.0.0rc2/cornflow_client.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests==2.32.4
+genson==1.2.2
+jsonschema==4.21.1
+marshmallow==3.26.2
+pytups==0.86.2
+ortools==9.8.3296
+PuLP==2.9.0

cornflow_client-2.0.0rc2/requirements.txt

@@ -0,0 +1,7 @@
+requests==2.32.4
+genson==1.2.2
+jsonschema==4.21.1
+marshmallow==3.26.2
+pytups==0.86.2
+ortools==9.8.3296
+PuLP==2.9.0

{cornflow_client-2.0.0a23 → cornflow_client-2.0.0rc2}/setup.py

@@ -12,7 +12,7 @@ extra_required = {"excel": ["openpyxl", "pandas"]}
 
 setuptools.setup(
     name="cornflow-client",
-    version="2.0.0a23",
+    version="2.0.0rc2",
     author="baobab soluciones",
     author_email="sistemas@baobabsoluciones.es",
     description="Client to connect to a cornflow server",
@@ -26,7 +26,7 @@ setuptools.setup(
         "Operating System :: OS Independent",
         "Development Status :: 5 - Production/Stable",
     ],
-    python_requires=">=3.9",
+    python_requires=">=3.10",
     include_package_data=True,
     install_requires=required,
     extra_require=extra_required,

cornflow_client-2.0.0a23/cornflow_client.egg-info/requires.txt

@@ -1,7 +0,0 @@
-requests<=2.32.4
-genson<=1.2.2
-jsonschema<=4.21.1
-marshmallow<=3.20.2
-pytups<=0.86.2
-ortools<=9.8.3296
-PuLP<=2.9.0

cornflow_client-2.0.0a23/requirements.txt

@@ -1,7 +0,0 @@
-requests<=2.32.4
-genson<=1.2.2
-jsonschema<=4.21.1
-marshmallow<=3.20.2
-pytups<=0.86.2
-ortools<=9.8.3296
-PuLP<=2.9.0