qarnot 2.17.0__tar.gz → 2.18.0__tar.gz

{qarnot-2.17.0/qarnot.egg-info → qarnot-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qarnot
-Version: 2.17.0
+Version: 2.18.0
 Summary: Qarnot Computing SDK
 Home-page: https://computing.qarnot.com
 Author: Qarnot computing
@@ -27,6 +27,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{qarnot-2.17.0 → qarnot-2.18.0}/doc/source/api/compute/computeindex.rst

@@ -15,4 +15,5 @@ Compute
    scheduling_type
    secrets
    carbon_facts
+   computing_quotas
 

qarnot-2.18.0/doc/source/api/compute/computing_quotas.rst

@@ -0,0 +1,8 @@
+Computing Quotas
+----------------
+
+.. automodule:: qarnot.computing_quotas
+    :members:
+    :show-inheritance:
+    :special-members:
+    :exclude-members: __dict__,__weakref__

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-05T10:05:53+0100",
+ "date": "2025-05-22T14:41:22+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "559a43baceed056873c5b9dab07d987025306be8",
- "version": "v2.17.0"
+ "full-revisionid": "9361585630d3dbcc8fa50ecbb9d20d592234a808",
+ "version": "v2.18.0"
 }
 '''  # END VERSION_JSON
 

qarnot-2.18.0/qarnot/computing_quotas.py

@@ -0,0 +1,328 @@
+# Copyright 2025 Qarnot computing
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, List, Dict, Any
+
+
+class UserSchedulingQuota(object):
+    """Describes a scheduling quota for the user.
+    """
+
+    def __init__(self, max_cores: int, running_cores_count: int, max_instances: int, running_instances_count: int):
+        """Create a new UserSchedulingQuota object describing a scheduling quota for the user.
+
+        :param int max_cores: Maximum number of cores that can be simultaneously used with this scheduling plan.
+        :param int running_cores_count: Number of cores that are currently running with this scheduling plan.
+        :param int max_instances: Maximum number of instances that can be simultaneously used with this scheduling plan.
+        :param int running_instances_count: Number of instances that are currently running with this scheduling plan.
+        :returns: The created :class:`~qarnot.computing_quotas.UserSchedulingQuota`.
+        """
+        self.max_cores = max_cores
+        """:type: :class:`int`
+
+        Maximum number of cores that can be simultaneously used with this scheduling plan.
+        """
+        self.running_cores_count = running_cores_count
+        """:type: :class:`int`
+
+        Number of cores that are currently running with this scheduling plan.
+        """
+        self.max_instances = max_instances
+        """:type: :class:`int`
+
+        Maximum number of instances that can be simultaneously used with this scheduling plan.
+        """
+        self.running_instances_count = running_instances_count
+        """:type: :class:`int`
+
+        Number of instances that are currently running with this scheduling plan.
+        """
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new UserSchedulingQuota object from json describing a scheduling quota for a user.
+
+        :param dict json: Dictionary representing the user scheduling plan
+        :returns: The created :class:`~qarnot.computing_quotas.UserSchedulingQuota`.
+        """
+        if json is None:
+            return None
+        return cls(
+            json.get('maxCores'),
+            json.get('runningCoresCount'),
+            json.get('maxInstances'),
+            json.get('runningInstancesCount'),
+        )
+
+
+class UserReservedSchedulingQuota(UserSchedulingQuota):
+    """Describes a reserved scheduling quota for the user.
+    """
+
+    def __init__(self, machine_key: str, max_cores: int, running_cores_count: int, max_instances: int, running_instances_count: int):
+        """Create a new UserReservedSchedulingQuota object describing a reserved scheduling quota for the user.
+
+        :param str machine_key: Machine key of the reservation.
+        :param int max_cores: Maximum number of cores that can be simultaneously used with this reserved machine specification.
+        :param int running_cores_count: Number of cores that are currently running with this reserved machine specification.
+        :param int max_instances: Maximum number of instances that can be simultaneously used with this reserved machine specification.
+        :param int running_instances_count: Number of instances that are currently running with this reserved machine specification.
+        :returns: The created :class:`~qarnot.computing_quotas.UserReservedSchedulingQuota`.
+        """
+        super().__init__(max_cores, running_cores_count, max_instances, running_instances_count)
+        self.machine_key = machine_key
+        """:type: :class:`str`
+
+        Machine key of the reservation.
+        """
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new UserReservedSchedulingQuota object from json describing a reserved scheduling quota for a user.
+
+        :param dict json: Dictionary representing the user reserved scheduling quota
+        :returns: The created :class:`~qarnot.computing_quotas.UserReservedSchedulingQuota`.
+        """
+        if json is None:
+            return None
+        return cls(
+            json.get('machineKey'),
+            json.get('maxCores'),
+            json.get('runningCoresCount'),
+            json.get('maxInstances'),
+            json.get('runningInstancesCount'),
+        )
+
+
+class UserComputingQuotas(object):
+    """Describes the user's computing quotas.
+    """
+
+    def __init__(self, flex: UserSchedulingQuota, on_demand: UserSchedulingQuota, reserved: List[UserReservedSchedulingQuota]):
+        """Create a new UserComputingQuotas object describing the user's computing quotas.
+
+        :param `~qarnot.computing_quotas.UserSchedulingQuota` flex: Quotas for Flex scheduling plan.
+        :param `~qarnot.computing_quotas.UserSchedulingQuota` on_demand: Quotas for OnDemand scheduling plan.
+        :param List of `~qarnot.computing_quotas.UserReservedSchedulingQuota` reserved: Quotas for Reserved scheduling plan.
+        :returns: The created :class:`~qarnot.computing_quotas.UserComputingQuotas`.
+        """
+        self.flex = flex
+        """:type: :class:`~qarnot.computing_quotas.UserSchedulingQuota`
+
+        Quotas for Flex scheduling plan."""
+        self.on_demand = on_demand
+        """:type: :class:`~qarnot.computing_quotas.UserSchedulingQuota`
+
+        Quotas for OnDemand scheduling plan."""
+        self.reserved = reserved
+        """:type: list(:class:`~qarnot.computing_quotas.UserReservedSchedulingQuota`)
+
+        Quotas for Reserved scheduling plan."""
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new UserComputingQuotas object from json describing the user's computing quotas.
+
+        :param dict json: Dictionary representing the user computing quota
+        :returns: The created :class:`~qarnot.computing_quotas.UserComputingQuotas`.
+        """
+        if json is None:
+            return None
+        return cls(
+            UserSchedulingQuota.from_json(json.get('flex')),
+            UserSchedulingQuota.from_json(json.get('onDemand')),
+            [UserReservedSchedulingQuota.from_json(v) for v in json.get('reserved', []) if v is not None]
+        )
+
+
+class OrganizationSchedulingQuota(object):
+    """Describes a scheduling quota for the organization.
+    """
+
+    def __init__(self, max_cores: int, running_cores_count: int, max_instances: int, running_instances_count: int):
+        """Create a new OrganizationSchedulingQuota object describing a scheduling quota for the organization.
+
+        :param int max_cores: Maximum number of cores that can be simultaneously used with this scheduling plan.
+        :param int running_cores_count: Number of cores that are currently running with this scheduling plan.
+        :param int max_instances: Maximum number of instances that can be simultaneously used with this scheduling plan.
+        :param int running_instances_count: Number of instances that are currently running with this scheduling plan.
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationSchedulingQuota`.
+        """
+        self.max_cores = max_cores
+        """:type: :class:`int`
+
+        Maximum number of cores that can be simultaneously used with this scheduling plan.
+        """
+        self.running_cores_count = running_cores_count
+        """:type: :class:`int`
+
+        Number of cores that are currently running with this scheduling plan.
+        """
+        self.max_instances = max_instances
+        """:type: :class:`int`
+
+        Maximum number of instances that can be simultaneously used with this scheduling plan.
+        """
+        self.running_instances_count = running_instances_count
+        """:type: :class:`int`
+
+        Number of instances that are currently running with this scheduling plan.
+        """
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new OrganizationSchedulingQuota object from json describing a scheduling quota for the organization.
+
+        :param dict json: Dictionary representing the organization scheduling plan
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationSchedulingQuota`.
+        """
+        if json is None:
+            return None
+        return cls(
+            json.get('maxCores'),
+            json.get('runningCoresCount'),
+            json.get('maxInstances'),
+            json.get('runningInstancesCount'),
+        )
+
+
+class OrganizationReservedSchedulingQuota(OrganizationSchedulingQuota):
+    """Describes a reserved scheduling quota for the organization.
+    """
+
+    def __init__(self, machine_key: str, max_cores: int, running_cores_count: int, max_instances: int, running_instances_count: int):
+        """Create a new OrganizationReservedSchedulingQuota object describing a reserved scheduling quota for the organization.
+
+        :param str machine_key: Machine key of the reservation.
+        :param int max_cores: Maximum number of cores that can be simultaneously used with this reserved machine specification.
+        :param int running_cores_count: Number of cores that are currently running with this reserved machine specification.
+        :param int max_instances: Maximum number of instances that can be simultaneously used with this reserved machine specification.
+        :param int running_instances_count: Number of instances that are currently running with this reserved machine specification.
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationReservedSchedulingQuota`.
+        """
+        super().__init__(max_cores, running_cores_count, max_instances, running_instances_count)
+        self.machine_key = machine_key
+        """:type: :class:`str`
+
+        Machine key of the reservation.
+        """
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new OrganizationReservedSchedulingQuota object from json describing a reserved scheduling quota for a organization.
+
+        :param dict json: Dictionary representing the organization reserved scheduling quota
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationReservedSchedulingQuota`.
+        """
+        if json is None:
+            return None
+        return cls(
+            json.get('machineKey'),
+            json.get('maxCores'),
+            json.get('runningCoresCount'),
+            json.get('maxInstances'),
+            json.get('runningInstancesCount'),
+        )
+
+
+class OrganizationComputingQuotas(object):
+    """Describes the organization's computing quotas.
+    """
+
+    def __init__(self, name: str, flex: OrganizationSchedulingQuota, on_demand: OrganizationSchedulingQuota, reserved: List[OrganizationReservedSchedulingQuota]):
+        """Create a new OrganizationComputingQuotas object describing the organization's computing quotas.
+
+        :param `str` name: Name of the organization.
+        :param `~qarnot.computing_quotas.OrganizationSchedulingQuota` flex: Quotas for Flex scheduling plan.
+        :param `~qarnot.computing_quotas.OrganizationSchedulingQuota` on_demand: Quotas for OnDemand scheduling plan.
+        :param List of `~qarnot.computing_quotas.OrganizationReservedSchedulingQuota` reserved: Quotas for Reserved scheduling plan.
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationComputingQuotas`.
+        """
+        self.name = name
+        """:type: :class:`str`
+
+        Name of the organization."""
+        self.flex = flex
+        """:type: :class:`~qarnot.computing_quotas.OrganizationSchedulingQuota`
+
+        Quotas for Flex scheduling plan."""
+        self.on_demand = on_demand
+        """:type: :class:`~qarnot.computing_quotas.OrganizationSchedulingQuota`
+
+        Quotas for OnDemand scheduling plan."""
+        self.reserved = reserved
+        """:type: list(:class:`~qarnot.computing_quotas.OrganizationReservedSchedulingQuota`)
+
+        Quotas for Reserved scheduling plan."""
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new OrganizationComputingQuotas object from json describing the organization's computing quotas.
+
+        :param dict json: Dictionary representing the organization computing quota
+        :returns: The created :class:`~qarnot.computing_quotas.OrganizationComputingQuotas`.
+        """
+        if json is None:
+            return None
+        return cls(
+            json.get('name'),
+            OrganizationSchedulingQuota.from_json(json.get('flex')),
+            OrganizationSchedulingQuota.from_json(json.get('onDemand')),
+            [OrganizationReservedSchedulingQuota.from_json(v) for v in json.get('reserved', []) if v is not None]
+        )
+
+
+class ComputingQuotas(object):
+    """Describes user and organization computing quotas.
+    """
+
+    def __init__(self, user_computing_quotas: Optional[UserComputingQuotas], organization_computing_quotas: Optional[OrganizationComputingQuotas] = None):
+        """Create a new ComputingQuotas object describing user and organization computing quotas.
+
+        :param user_computing_quotas: the user related computing quotas
+        :type user_computing_quotas: `~qarnot.computing_quotas.UserComputingQuotas`, optional
+        :param organization_computing_quotas: the organization related computing quotas
+        :type organization_computing_quotas: `~qarnot.computing_quotas.OrganizationComputingQuotas`, optional
+        :returns: The created :class:`~qarnot.computing_quotas.ComputingQuotas`.
+        """
+        self.user = user_computing_quotas
+        """:type: :class:`~qarnot.computing_quotas.UserComputingQuotas`
+
+        The user related computing quotas."""
+        self.organization = organization_computing_quotas
+        """:type: :class:`~qarnot.computing_quotas.OrganizationComputingQuotas`
+
+        The organization related computing quotas."""
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a new ComputingQuotas object from json describing user and organization computing quotas.
+
+        :param dict json: Dictionary representing the computing quotas
+        :returns: The created :class:`~qarnot.computing_quotas.ComputingQuotas`
+        """
+        if json is None:
+            return None
+        user_computing_quotas = UserComputingQuotas.from_json(json.get('user'))
+        organization_computing_quotas = OrganizationComputingQuotas.from_json(json.get('organization'))
+        return cls(user_computing_quotas, organization_computing_quotas)
+
+    @classmethod
+    def from_json_legacy(cls, json: Dict[str, Any]):
+        if json is None:
+            return None
+        flex = UserSchedulingQuota(json.get('maxFlexCores'), json.get('runningFlexCoreCount'), json.get('maxFlexInstances'), json.get('runningFlexInstanceCount'))
+        onDemand = UserSchedulingQuota(json.get('maxOnDemandCores'), json.get('runningOnDemandCoreCount'), json.get('maxOnDemandInstances'), json.get('runningOnDemandInstanceCount'))
+        user = UserComputingQuotas(flex, onDemand, [])
+        return cls(user, None)

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot/connection.py

@@ -28,6 +28,7 @@ from .task import Task, BulkTaskResponse
 from .pool import Pool
 from .paginate import PaginateResponse, OffsetResponse
 from .bucket import Bucket
+from .computing_quotas import ComputingQuotas
 from .job import Job
 from ._filter import create_pool_filter, create_task_filter, create_job_filter
 from ._retry import with_retry
@@ -95,8 +96,8 @@ class Connection(object):
            unsafe=False
 
         """
-        self.logger = logger if logger is not None else Log.get_logger_for_stream(sys.stdout)
-        self.logger_stderr = logger if logger is not None else Log.get_logger_for_stream(sys.stderr)  # to avoid breaking change of task stderr logs
+        self.logger = logger if logger is not None else Log.get_logger_for_stream(sys.stdout, "stdout")
+        self.logger_stderr = logger if logger is not None else Log.get_logger_for_stream(sys.stderr, "stderr")  # to avoid breaking change of task stderr logs
         self._version = "qarnot-sdk-python/" + __version__
         self._http = requests.session()
         self._retry_count = retry_count
@@ -997,21 +998,37 @@ class UserInfo(object):
         """:type: :class:`int`
 
         Number of cores currently submitted or running."""
-        self.max_flex_instances = info.get('maxFlexInstances')
+        self.computing_quotas = ComputingQuotas.from_json(info.get('computingQuotas')) or ComputingQuotas.from_json_legacy(info)
+        """:type: :class:`~qarnot.computing_quotas.ComputingQuotas`
+
+        Computing quotas information of the user and his organization."""
+        self.max_flex_instances = self.computing_quotas.user.flex.max_instances if self.computing_quotas is not None else info.get('maxFlexInstances')
         """:type: :class:`int`
 
+        .. deprecated:: v2.18.0
+           Use `self.computing_quotas` instead.
+
         Maximum number of instances simultaneously used with Flex scheduling plan."""
-        self.max_flex_cores = info.get('maxFlexCores')
+        self.max_flex_cores = self.computing_quotas.user.flex.max_cores if self.computing_quotas is not None else info.get('maxFlexCores')
         """:type: :class:`int`
 
+        .. deprecated:: v2.18.0
+           Use `self.computing_quotas` instead.
+
         Maximum number of cores simultaneously used with Flex scheduling plan."""
-        self.max_on_demand_instances = info.get('maxOnDemandInstances')
+        self.max_on_demand_instances = self.computing_quotas.user.on_demand.max_instances if self.computing_quotas is not None else info.get('maxOnDemandInstances')
         """:type: :class:`int`
 
+        .. deprecated:: v2.18.0
+           Use `self.computing_quotas` instead.
+
         Maximum number of instances simultaneously used with OnDemand scheduling plan."""
-        self.max_on_demand_cores = info.get('maxOnDemandCores')
+        self.max_on_demand_cores = self.computing_quotas.user.on_demand.max_cores if self.computing_quotas is not None else info.get('maxOnDemandCores')
         """:type: :class:`int`
 
+        .. deprecated:: v2.18.0
+           Use `self.computing_quotas` instead.
+
         Maximum number of cores simultaneously used with OnDemand scheduling plan."""
 
 

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot/helper.py

@@ -14,7 +14,7 @@ class Log():
     """
 
     @staticmethod
-    def get_logger_for_stream(stream: TextIO = None, log_format: str = DEFAULT_LOG_FORMAT):
+    def get_logger_for_stream(stream: TextIO = None, name: str = None, log_format: str = DEFAULT_LOG_FORMAT):
         """Create a logger whose output is a stream.
 
         :param TextIO stream:
@@ -31,12 +31,13 @@ class Log():
         :rtype: logging.Logger
         :returns: The created logger.
         """
-
+        if name is None:
+            name = __name__
         formatter = logging.Formatter(log_format)
         handler = logging.StreamHandler(stream if stream is not None else sys.stdout)
         handler.setFormatter(formatter)
 
-        logger = logging.getLogger(__name__)
+        logger = logging.getLogger(name)
         logger.addHandler(handler)
         logger.setLevel(logging.INFO)
         return logger

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot/pool.py

@@ -114,6 +114,7 @@ class Pool(object):
         self._queued_or_running_task_instances_count = 0.0
 
         self._completion_time_to_live = "00:00:00"
+        self._max_time_queue_seconds: int = None
         self._auto_delete = False
         self._tasks_wait_for_synchronization = False
 
@@ -215,6 +216,8 @@ class Pool(object):
         if 'completionTimeToLive' in json_pool:
             self._completion_time_to_live = json_pool.get("completionTimeToLive")
 
+        self._max_time_queue_seconds = json_pool.get("maxTimeQueueSeconds", None)
+
         if 'elasticProperty' in json_pool:
             elasticProperty = json_pool.get("elasticProperty")
             self._is_elastic = elasticProperty.get("isElastic")
@@ -297,6 +300,9 @@ class Pool(object):
         json_pool['privileges'] = self._privileges.to_json()
         json_pool['defaultRetrySettings'] = self._default_retry_settings.to_json()
 
+        if self._max_time_queue_seconds is not None:
+            json_pool['maxTimeQueueSeconds'] = self._max_time_queue_seconds
+
         if self._scheduling_type is not None:
             json_pool['schedulingType'] = self._scheduling_type.schedulingType
 
@@ -1431,6 +1437,22 @@ class Pool(object):
 
         self._privileges._exportApiAndStorageCredentialsInEnvironment = True
 
+    @property
+    def max_time_queue_seconds(self):
+        """
+        :type: :class:`uint`
+        :getter: Max time to wait before time out when there is not any place to execute the pool.
+
+        pool's max time queue seconds
+        """
+        self._update_if_summary()
+        return self._max_time_queue_seconds
+
+    @max_time_queue_seconds.setter
+    def max_time_queue_seconds(self, value: int):
+        """Setter for max_time_queue_seconds."""
+        self._max_time_queue_seconds = value
+
     @property
     def default_retry_settings(self) -> RetrySettings:
         """:type: :class:`~qarnot.retry_settings.RetrySettings`

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot/task.py

@@ -19,7 +19,7 @@ from os import makedirs, path
 import time
 import warnings
 import sys
-from typing import Dict, Optional, Union, List, Any, Callable
+from typing import Dict, Optional, Union, List, Any, Callable, Sequence
 
 from qarnot.carbon_facts import CarbonClient, CarbonFacts
 from qarnot.retry_settings import RetrySettings
@@ -40,6 +40,7 @@ from .exceptions import MissingTaskException, MaxTaskException, NotEnoughCredits
 
 try:
     from progressbar import AnimatedMarker, Bar, Percentage, AdaptiveETA, ProgressBar
+    from progressbar.widgets import WidgetBase
 except ImportError:
     pass
 
@@ -172,6 +173,7 @@ class Task(object):
         self._progress = None
         self._execution_time = None
         self._wall_time = None
+        self._max_time_queue_seconds: int = None
         self._end_date = None
         self._upload_results_on_cancellation: Optional[bool] = None
         self._hardware_constraints: List[HardwareConstraint] = []
@@ -513,6 +515,7 @@ class Task(object):
         self._progress = json_task.get("progress", None)
         self._execution_time = json_task.get("executionTime", None)
         self._wall_time = json_task.get("wallTime", None)
+        self._max_time_queue_seconds = json_task.get("maxTimeQueueSeconds", None)
         self._end_date = json_task.get("endDate", None)
         self._labels = json_task.get("labels", {})
         self._hardware_constraints = [HardwareConstraint.from_json(hw_constraint_dict) for hw_constraint_dict in json_task.get("hardwareConstraints", [])]
@@ -589,7 +592,7 @@ class Task(object):
 
         if live_progress:
             try:
-                widgets = [
+                widgets: Sequence[WidgetBase | str] = [
                     Percentage(),
                     ' ', AnimatedMarker(),
                     ' ', Bar(),
@@ -1778,6 +1781,22 @@ class Task(object):
         self._update_if_summary()
         return self._wall_time
 
+    @property
+    def max_time_queue_seconds(self):
+        """
+        :type: :class:`uint`
+        :getter: Max time to wait before time out when there is not any place to execute the task.
+
+        task's max time queue seconds
+        """
+        self._update_if_summary()
+        return self._max_time_queue_seconds
+
+    @max_time_queue_seconds.setter
+    def max_time_queue_seconds(self, value: int):
+        """Setter for max_time_queue_seconds."""
+        self._max_time_queue_seconds = value
+
     @property
     def snapshot_interval(self):
         """
@@ -1836,6 +1855,9 @@ class Task(object):
         self._resource_object_advanced = [x.to_json() for x in self._resource_objects]
         json_task['advancedResourceBuckets'] = self._resource_object_advanced
 
+        if self._max_time_queue_seconds is not None:
+            json_task['maxTimeQueueSeconds'] = self._max_time_queue_seconds
+
         if self._result_object is not None:
             json_task['resultBucket'] = self._result_object.uuid
             if self._result_object._cache_ttl_sec is not None:

{qarnot-2.17.0 → qarnot-2.18.0/qarnot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qarnot
-Version: 2.17.0
+Version: 2.18.0
 Summary: Qarnot Computing SDK
 Home-page: https://computing.qarnot.com
 Author: Qarnot computing
@@ -27,6 +27,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{qarnot-2.17.0 → qarnot-2.18.0}/qarnot.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ doc/source/api/connection.rst
 doc/source/api/exceptions.rst
 doc/source/api/compute/carbon_facts.rst
 doc/source/api/compute/computeindex.rst
+doc/source/api/compute/computing_quotas.rst
 doc/source/api/compute/forced_network_rule.rst
 doc/source/api/compute/hardware_constraint.rst
 doc/source/api/compute/job.rst
@@ -45,6 +46,7 @@ qarnot/_version.py
 qarnot/advanced_bucket.py
 qarnot/bucket.py
 qarnot/carbon_facts.py
+qarnot/computing_quotas.py
 qarnot/connection.py
 qarnot/error.py
 qarnot/exceptions.py

qarnot-2.18.0/requirements.txt

@@ -0,0 +1,6 @@
+requests==2.32.3
+boto3==1.38.18
+wheel==0.45.1
+deprecation==2.1.0
+simplejson==3.20.1
+setuptools==80.7.1

{qarnot-2.17.0 → qarnot-2.18.0}/test/test_connection.py

@@ -442,7 +442,7 @@ class TestConnectionPaginateMethods():
                 next(iterator)
             assert mock_page_call.call_count == 2
 
-    def test_user_information(self):
+    def test_user_information_legacy_computing_quotas(self):
         connec = self.get_connection()
         with patch("qarnot.connection.Connection._get") as get_user:
             user_json = {
@@ -464,8 +464,12 @@ class TestConnectionPaginateMethods():
                 "runningCoreCount":19,
                 "maxFlexInstances":20,
                 "maxFlexCores":21,
-                "maxOnDemandInstances":22,
-                "maxOnDemandCores":23,
+                "runningFlexCoreCount":22,
+                "runningFlexInstanceCount":23,
+                "maxOnDemandInstances":24,
+                "maxOnDemandCores":25,
+                "runningOnDemandCoreCount":26,
+                "runningOnDemandInstanceCount":27,
             }
             get_user.return_value.status_code = 200
             get_user.return_value.json.return_value = user_json
@@ -492,6 +496,117 @@ class TestConnectionPaginateMethods():
             assert user.max_on_demand_instances == user_json['maxOnDemandInstances']
             assert user.max_on_demand_cores == user_json['maxOnDemandCores']
 
+            assert user.computing_quotas.user.flex.max_instances == user_json['maxFlexInstances']
+            assert user.computing_quotas.user.flex.max_cores == user_json['maxFlexCores']
+            assert user.computing_quotas.user.flex.running_cores_count == user_json['runningFlexCoreCount']
+            assert user.computing_quotas.user.flex.running_instances_count == user_json['runningFlexInstanceCount']
+            assert user.computing_quotas.user.on_demand.max_instances == user_json['maxOnDemandInstances']
+            assert user.computing_quotas.user.on_demand.max_cores == user_json['maxOnDemandCores']
+            assert user.computing_quotas.user.on_demand.running_cores_count == user_json['runningOnDemandCoreCount']
+            assert user.computing_quotas.user.on_demand.running_instances_count == user_json['runningOnDemandInstanceCount']
+            assert user.computing_quotas.user.reserved == []
+
+    def test_user_information_new_format_computing_quotas(self):
+        connec = self.get_connection()
+        with patch("qarnot.connection.Connection._get") as get_user:
+            user_json = {
+                "email":"",
+                "maxBucket":5,
+                "bucketCount":6,
+                "quotaBytesBucket":7,
+                "usedQuotaBytesBucket":8,
+                "taskCount":9,
+                "maxTask":10,
+                "runningTaskCount":11,
+                "maxRunningTask":12,
+                "maxInstances":13,
+                "maxPool":14,
+                "poolCount":15,
+                "maxRunningPool":16,
+                "runningPoolCount":17,
+                "runningInstanceCount":18,
+                "runningCoreCount":19,
+                "computingQuotas": {
+                    "user": {
+                        "flex": {
+                            "maxInstances": 64,
+                            "maxCores": 512,
+                            "runningInstancesCount": 1,
+                            "runningCoresCount": 2
+                        },
+                        "onDemand": {
+                            "maxInstances": 642,
+                            "maxCores": 5122,
+                            "runningInstancesCount": 3,
+                            "runningCoresCount": 4
+                        },
+                        "reserved": [
+                            {
+                                "machineKey": "string",
+                                "maxInstances": 643,
+                                "maxCores": 5123,
+                                "runningInstancesCount": 5,
+                                "runningCoresCount": 6
+                            }
+                        ]
+                    },
+                    "organization": {
+                        "name": "string",
+                        "flex": {
+                            "maxInstances": 644,
+                            "maxCores": 5124,
+                            "runningInstancesCount": 7,
+                            "runningCoresCount": 8
+                        },
+                        "onDemand": {
+                            "maxInstances": 645,
+                            "maxCores": 5125,
+                            "runningInstancesCount": 9,
+                            "runningCoresCount": 10
+                        },
+                        "reserved": [
+                            {
+                                "machineKey": "string",
+                                "maxInstances": 646,
+                                "maxCores": 5126,
+                                "runningInstancesCount": 11,
+                                "runningCoresCount": 12
+                            }
+                        ]
+                    }
+                },
+            }
+            get_user.return_value.status_code = 200
+            get_user.return_value.json.return_value = user_json
+            user = connec.user_info
+            assert user.email == user_json.get('email', '')
+            assert user.max_bucket == user_json['maxBucket']
+            assert user.bucket_count == user_json.get('bucketCount', -1)
+            assert user.quota_bytes_bucket == user_json['quotaBytesBucket']
+            assert user.used_quota_bytes_bucket == user_json['usedQuotaBytesBucket']
+            assert user.task_count == user_json['taskCount']
+            assert user.max_task == user_json['maxTask']
+            assert user.running_task_count == user_json['runningTaskCount']
+            assert user.max_running_task == user_json['maxRunningTask']
+            assert user.max_instances == user_json['maxInstances']
+            assert user.max_pool == user_json['maxPool']
+            assert user.pool_count == user_json['poolCount']
+            assert user.max_running_pool == user_json['maxRunningPool']
+            assert user.running_pool_count == user_json['runningPoolCount']
+            assert user.running_instance_count == user_json['runningInstanceCount']
+            assert user.running_core_count == user_json['runningCoreCount']
+
+
+            assert user.computing_quotas.user.flex.max_instances == user_json['computingQuotas']['user']['flex']['maxInstances']
+            assert user.computing_quotas.user.flex.max_cores == user_json['computingQuotas']['user']['flex']['maxCores']
+            assert user.computing_quotas.user.flex.running_cores_count == user_json['computingQuotas']['user']['flex']['runningCoresCount']
+            assert user.computing_quotas.user.flex.running_instances_count == user_json['computingQuotas']['user']['flex']['runningInstancesCount']
+
+            assert user.computing_quotas.organization.on_demand.max_instances == user_json['computingQuotas']['organization']['onDemand']['maxInstances']
+            assert user.computing_quotas.organization.on_demand.max_cores == user_json['computingQuotas']['organization']['onDemand']['maxCores']
+            assert user.computing_quotas.organization.on_demand.running_cores_count == user_json['computingQuotas']['organization']['onDemand']['runningCoresCount']
+            assert user.computing_quotas.organization.on_demand.running_instances_count == user_json['computingQuotas']['organization']['onDemand']['runningInstancesCount']
+
     def test_user_with_missing_information(self): # To ensure it doesn't throw when modifying a field in rest-computing side
         connec = self.get_connection()
         with patch("qarnot.connection.Connection._get") as get_user:

{qarnot-2.17.0 → qarnot-2.18.0}/test/test_pool.py

@@ -44,14 +44,31 @@ class TestPoolProperties:
         pool.completion_ttl = "4.11:08:06"
         assert "4.11:08:06" == pool.completion_ttl
 
-    def test_pool_are_in_pool_to_json(self):
+    def test_fields_are_in_json_from_task(self):
         pool = Pool(self.conn, "pool-name", "profile")
         pool.completion_ttl = "4.11:08:06"
         pool.auto_delete = True
+        pool.max_time_queue_seconds = 10
         json_pool = pool._to_json()
 
         assert json_pool['completionTimeToLive'] == '4.11:08:06'
         assert json_pool['autoDeleteOnCompletion'] == True
+        assert json_pool['maxTimeQueueSeconds'] == 10
+
+    def test_fields_are_in_task_from_json(self):
+        json_pool = {}
+        json_pool['maxTimeQueueSeconds'] = 10
+
+        # fields that need to be non null for the deserialization to not fail
+        json_pool['creationDate'] = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+        json_pool['uuid'] = str(uuid.uuid4())
+        json_pool['state'] = 'Submitted'
+        json_pool['runningCoreCount'] = 0
+        json_pool['runningInstanceCount'] = 0
+
+        pool_from_json = Pool(self.conn, "pool-name", "profile")
+        pool_from_json._update(json_pool)
+        assert pool_from_json.max_time_queue_seconds == 10
 
     def test_update_resources_send_the_good_url(self):
         update_connection = MockConnection()
@@ -70,6 +87,7 @@ class TestPoolProperties:
         ("execution_time", None),
         ("end_date", None),
         ("tasks_default_wait_for_pool_resources_synchronization", False),
+        ("max_time_queue_seconds", None),
         ("privileges", Privileges()),
     ])
     def test_pool_property_default_value(self, property_name,  expected_value):
@@ -96,12 +114,21 @@ class TestPoolProperties:
         ("privileges", default_json_pool["privileges"]),
         ("defaultRetrySettings", default_json_pool["defaultRetrySettings"]),
     ])
-    def test_pool_property_send_to_json_representation(self, property_name, expected_value):
+    def test_pool_property_with_default_send_to_json_representation(self, property_name, expected_value):
         pool = Pool(self.conn, "pool-name", "profile")
         pool._update(default_json_pool)
         pool_json = pool._to_json()
         assert pool_json[property_name] == expected_value
 
+    @pytest.mark.parametrize("property_name", [
+        ("max_time_queue_seconds"),
+    ])
+    def test_task_property_default_not_send_in_json(self, property_name):
+        pool = Pool(self.conn, "pool-name", "profile")
+        pool._update(default_json_pool)
+        pool_json = pool._to_json()
+        assert property_name not in pool_json
+
     @pytest.mark.parametrize("property_name, set_value, expected_value", [
         ("name", "name", "name")
     ])

{qarnot-2.17.0 → qarnot-2.18.0}/test/test_task.py

@@ -50,14 +50,31 @@ class TestTaskProperties:
         task.completion_ttl = "4.11:08:06"
         assert "4.11:08:06" == task.completion_ttl
 
-    def test_task_are_in_task_to_json(self, mock_conn):
+    def test_fields_are_in_json_from_task(self, mock_conn):
         task = Task(mock_conn, "task-name")
         task.completion_ttl = "4.11:08:06"
         task.auto_delete = True
+        task.max_time_queue_seconds = 10
         json_task = task._to_json()  # pylint: disable=protected-access
 
         assert json_task['completionTimeToLive'] == '4.11:08:06'
         assert json_task['autoDeleteOnCompletion'] is True
+        assert json_task['maxTimeQueueSeconds'] == 10
+
+    def test_fields_are_in_task_from_json(self, mock_conn):
+        json_task = {}
+        json_task['maxTimeQueueSeconds'] = 10
+
+        # fields that need to be non null for the deserialization to not fail
+        json_task['creationDate'] = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+        json_task['uuid'] = str(uuid.uuid4())
+        json_task['state'] = 'Submitted'
+        json_task['runningCoreCount'] = 0
+        json_task['runningInstanceCount'] = 0
+
+        task = Task.from_json(mock_conn, json_task)
+        assert task.max_time_queue_seconds == 10
+
 
     @pytest.mark.parametrize("property_name, expected_value", [
         ("previous_state", None),
@@ -69,6 +86,7 @@ class TestTaskProperties:
         ("execution_time", None),
         ("wall_time", None),
         ("end_date", None),
+        ("max_time_queue_seconds", None),
         ("privileges", Privileges()),
     ])
     def test_task_property_default_value(self, mock_conn, property_name,  expected_value):
@@ -103,6 +121,14 @@ class TestTaskProperties:
         task_json = task._to_json()
         assert task_json[property_name] == expected_value
 
+    @pytest.mark.parametrize("property_name", [
+        ("max_time_queue_seconds"),
+    ])
+    def test_task_property_default_not_send_in_json(self, mock_conn, property_name):
+        task = Task(mock_conn, "task-name")
+        task_json = task._to_json()
+        assert property_name not in task_json
+
     @pytest.mark.parametrize("property_name, set_value, expected_value", [
         ("name", "name", "name")
     ])
@@ -499,8 +525,8 @@ class TestTaskProperties:
         capturedStderr = StringIO()
         sys.stderr = capturedStderr
 
-        mock_conn.logger = Log.get_logger_for_stream(sys.stdout)
-        mock_conn.logger_stderr = Log.get_logger_for_stream(sys.stderr)
+        mock_conn.logger = Log.get_logger_for_stream(sys.stdout, "stdout")
+        mock_conn.logger_stderr = Log.get_logger_for_stream(sys.stderr, "stderr")
         # Mock the responses for task update
         task = Task(mock_conn, "task-name")
         task_json = copy.deepcopy(default_json_task)
@@ -563,6 +589,10 @@ class TestTaskProperties:
         assert warn_logs is not None, "the stderr should contain task update stderr"
         for state in states:
             assert state in info_logs, "All state updates should be printed on stdout"
+            assert info_logs.count(state) == 1, "All state logs should be printed only once"
         for i in range(0,len(states)):
             assert "stdout %s" % i in info_logs, "All task stdout should be printed to user logs stream with info level"
+            assert info_logs.count("stdout %s" % i) == 2, "All stdout logs should be printed only once" # each stdout logs are here sent twice in the test (before and after state change)
             assert "stderr %s" % i in warn_logs, "All task stderr should be printed to user logs stream with warning level"
+            assert warn_logs.count("stderr %s" % i) == 2, "All stderr logs should be printed only once" # each stderr logs are here sent twice in the test (before and after state change)
+            assert "stderr %s" % i not in info_logs, "All task stderr should not be printed to user logs stream with info level"

qarnot-2.17.0/requirements.txt

@@ -1,6 +0,0 @@
-requests==2.32.3
-boto3==1.36.6
-wheel==0.45.1
-deprecation==2.1.0
-simplejson==3.19.3
-setuptools==75.7.0