qarnot 2.17.0__py3-none-any.whl → 2.18.0__py3-none-any.whl

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/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/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/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/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/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.dist-info → qarnot-2.18.0.dist-info}/METADATA

@@ -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.dist-info → qarnot-2.18.0.dist-info}/RECORD

@@ -2,29 +2,30 @@ qarnot/__init__.py,sha256=BCIFvWIe1EbzdZAMeKnyK9HYIqNHlSsbaaDMIL7VghA,5626
 qarnot/_filter.py,sha256=J--0lOY2rverPEE3zrvuipYkOd9T_4HrW4eVNJqheac,10109
 qarnot/_retry.py,sha256=4QdtI5Y_Jshja8zDxhx_g17dzABCIUGXQsjcPl65u7g,890
 qarnot/_util.py,sha256=fmAq55CmfDTTB7yaOLspayC3Mvre7SCzp0YwWsnwpDA,5673
-qarnot/_version.py,sha256=chMgPEmbIXhGcBM27CW6fzvB4p7Bey3pm6cl8OJmKEI,499
+qarnot/_version.py,sha256=7tz02m0CSFBqrG9O7MBXuCGhUSa4292fCRUFrZqcSI4,499
 qarnot/advanced_bucket.py,sha256=dfhHOz0foJfEQoaCdGiS_-28w4Y6rq36ZloPgoEQiLE,7927
 qarnot/bucket.py,sha256=aNuJqfYUm2YCQ0m8SBl384xspYkc9SJy6_G-FEKs8nk,24449
 qarnot/carbon_facts.py,sha256=E_tBMsa2byEMgKAEilIFRsCE6_T978Zl7-ZXk4--PPI,10292
-qarnot/connection.py,sha256=qdwKRE66qeag9DKmLwK6VM0ppcK8h0Y2kyMjt3Y9F9o,45006
+qarnot/computing_quotas.py,sha256=qK-aJFKKi8TGarQ_QX2rM4rjDsg3iMV__hgxikIgNy0,15418
+qarnot/connection.py,sha256=x71AuXeO33iyxbdoWEQecjsyI_8VSvX7PXztzsNpzLE,46022
 qarnot/error.py,sha256=WCkkILJzOi06Q5QRBfacU41D0MQeFCPsQc9Ub1Y6SXw,734
 qarnot/exceptions.py,sha256=yt_iwCw_9pFdoKeOTxsr05kqW5Gu-th3gSfos5zI26g,2729
 qarnot/forced_constant.py,sha256=-i4b_JO10YiWuJ7Q0bmWE_TEwtf8qSeLlkMTAbH55EM,1309
 qarnot/forced_network_rule.py,sha256=g83LOCRy3c6e5WayQMlk-eYUXQFZICROLh6FDQ8G73k,4515
 qarnot/hardware_constraint.py,sha256=YZi4FgaJQ84mxVDT4u2WxqJ-i_bikwssidTRHRc3JHA,13694
-qarnot/helper.py,sha256=SAMcXt2GEcPuhV_ZzTOYs1Ucy4OdYGHVur472k36uoI,1498
+qarnot/helper.py,sha256=HWy0ollEMoGvCXbAY_FfgkhJjpHRRmkNtavvrJba2PY,1564
 qarnot/job.py,sha256=bag9NbugWCSf18J2c6nFKmWFFusXP58dfYYxd8CMsy8,19508
 qarnot/paginate.py,sha256=DaUYDPAS0M8hf0hph8GuMSzTASymSUOpp-WqbfevX-s,1387
-qarnot/pool.py,sha256=xBpRXQ0HB9u6fkdbDT18kbwUw9gErycKbUaL9TZ1-AQ,56269
+qarnot/pool.py,sha256=dUSOOkuFhNyR3Yr07svLKNBlzITddyoJR1wOtmKgpxA,57033
 qarnot/privileges.py,sha256=6j3n8q_RNdZ8bBPD9misHEpS0CbcQByqzxlOu8CS-rU,1896
 qarnot/retry_settings.py,sha256=Illobh-1U8hPdzkffJu5TFKM_NdzCNYS2j1teBljX94,2512
 qarnot/scheduling_type.py,sha256=j90APc1ji7xe2Z9OH9l81tjO12k0Wf9bSaG-_UCyeNI,2223
 qarnot/secrets.py,sha256=v6-1UNhCnnW71eJYMeqhcUYLHnsnONGi4Qa3aoiG9qc,12354
 qarnot/status.py,sha256=dCVsh9_ewIASZcreATbUd2qJ-cUMk0cRkyVLdrOot3Q,12348
 qarnot/storage.py,sha256=jAist_J_6yzmRrkF5jqYNG3mhEP_y7KqCdNv4dJcHuM,6929
-qarnot/task.py,sha256=RCjJBKziSsmaeM4X8mwETw8zWmuvBinNPrYM8SNDdNU,75285
-qarnot-2.17.0.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-qarnot-2.17.0.dist-info/METADATA,sha256=Lu6BjY0AJyHk86KwBLu2_CC9vupq-Td07c2Yh2xFeKY,2521
-qarnot-2.17.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-qarnot-2.17.0.dist-info/top_level.txt,sha256=acRyoLZNyf_kuGTwHQgfZv2MfdTcZstyNjBhOxFtHzU,7
-qarnot-2.17.0.dist-info/RECORD,,
+qarnot/task.py,sha256=Opg7QwZP2dZjPA4tCWkobqayoEHrmHCDc_-L_nSFQCo,76133
+qarnot-2.18.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+qarnot-2.18.0.dist-info/METADATA,sha256=AnWFGHWQ2zUU8IruRuLng4hMokzfhsyn7bDE6aMbCnQ,2543
+qarnot-2.18.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+qarnot-2.18.0.dist-info/top_level.txt,sha256=acRyoLZNyf_kuGTwHQgfZv2MfdTcZstyNjBhOxFtHzU,7
+qarnot-2.18.0.dist-info/RECORD,,

{qarnot-2.17.0.dist-info → qarnot-2.18.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any