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

qarnot/__init__.py

@@ -62,6 +62,7 @@ def get_url(key, **kwargs):
         'task update': '/tasks/{uuid}',  # GET->result; DELETE -> abort, PATCH -> update resources
         'task snapshot': '/tasks/{uuid}/snapshot/periodic',  # POST -> snapshots
         'task instant': '/tasks/{uuid}/snapshot',  # POST -> get a snapshot
+        'task instant status': '/tasks/{uuid}/snapshot/{snapshotId}',  # GET -> get a snapshot status
         'task stdout': '/tasks/{uuid}/stdout',  # GET -> task stdout
         'task stderr': '/tasks/{uuid}/stderr',  # GET -> task stderr
         'task instance stdout': '/tasks/{uuid}/stdout/{instanceId}',  # GET -> task instance stdout

qarnot/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-05-22T14:41:22+0200",
+ "date": "2026-02-06T11:26:35+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "9361585630d3dbcc8fa50ecbb9d20d592234a808",
- "version": "v2.18.0"
+ "full-revisionid": "a21d5058a77a68da123d95dd64550400fafb2bd2",
+ "version": "v2.20.1"
 }
 '''  # END VERSION_JSON
 

qarnot/computing_quotas.py

@@ -70,7 +70,7 @@ 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):
+    def __init__(self, reservation_name: str, 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.
@@ -86,6 +86,11 @@ class UserReservedSchedulingQuota(UserSchedulingQuota):
 
         Machine key of the reservation.
         """
+        self.reservation_name = reservation_name
+        """:type: :class:`str`
+
+        Name of the reservation.
+        """
 
     @classmethod
     def from_json(cls, json: Dict[str, Any]):
@@ -97,6 +102,7 @@ class UserReservedSchedulingQuota(UserSchedulingQuota):
         if json is None:
             return None
         return cls(
+            json.get('reservationName'),
             json.get('machineKey'),
             json.get('maxCores'),
             json.get('runningCoresCount'),
@@ -142,7 +148,7 @@ class UserComputingQuotas(object):
         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]
+            [UserReservedSchedulingQuota.from_json(v) for v in (json.get('reserved') if json.get('reserved') is not None else []) if v is not None]
         )
 
 
@@ -201,7 +207,7 @@ 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):
+    def __init__(self, reservation_name: str, 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.
@@ -217,6 +223,11 @@ class OrganizationReservedSchedulingQuota(OrganizationSchedulingQuota):
 
         Machine key of the reservation.
         """
+        self.reservation_name = reservation_name
+        """:type: :class:`str`
+
+        Name of the reservation.
+        """
 
     @classmethod
     def from_json(cls, json: Dict[str, Any]):
@@ -228,6 +239,7 @@ class OrganizationReservedSchedulingQuota(OrganizationSchedulingQuota):
         if json is None:
             return None
         return cls(
+            json.get('reservationName'),
             json.get('machineKey'),
             json.get('maxCores'),
             json.get('runningCoresCount'),
@@ -279,7 +291,7 @@ class OrganizationComputingQuotas(object):
             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]
+            [OrganizationReservedSchedulingQuota.from_json(v) for v in (json.get('reserved') if json.get('reserved') is not None else []) if v is not None]
         )
 
 

qarnot/forced_network_rule.py

@@ -20,7 +20,18 @@ class ForcedNetworkRule(object):
             priority: str = None,
             description: str = None,
             to_qbox: Optional[bool] = None,
-            to_payload: Optional[bool] = None):
+            to_payload: Optional[bool] = None,
+            name: str = None,
+            application_type: str = None):
+
+        self.name = name
+        """:type: :class:`str`
+
+        Name of the associated rule."""
+        self.application_type = application_type
+        """:type: :class:`str`
+
+        Application layer protocol used / hint about it (e.g. ssh, http, https...)."""
         self.inbound = inbound
         """:type: :class:`bool`
 
@@ -84,6 +95,14 @@ class ForcedNetworkRule(object):
         :returns: The created :class:`~qarnot.forced_network_rule.ForcedNetworkRule`
         """
 
+        name: str = None
+        if 'name' in json:
+            name = str(json.get("name"))
+
+        application_type: str = None
+        if 'applicationType' in json:
+            application_type = str(json.get("applicationType"))
+
         inbound: bool = bool(json.get("inbound"))
         proto: str = str(json.get("proto"))
 
@@ -96,12 +115,12 @@ class ForcedNetworkRule(object):
             to = str(json.get("to"))
 
         public_host: str = None
-        if 'public_host' in json:
-            public_host = str(json.get("public_host"))
+        if 'publicHost' in json:
+            public_host = str(json.get("publicHost"))
 
         public_port: str = None
-        if 'public_port' in json:
-            public_port = str(json.get("public_port"))
+        if 'publicPort' in json:
+            public_port = str(json.get("publicPort"))
 
         forwarder: str = None
         if 'forwarder' in json:
@@ -116,12 +135,12 @@ class ForcedNetworkRule(object):
             description = str(json.get("description"))
 
         to_qbox: Optional[bool] = None
-        if 'to_qbox' in json:
-            to_qbox = bool(json.get("to_qbox"))
+        if 'toQBox' in json:
+            to_qbox = bool(json.get("toQBox"))
 
         to_payload: Optional[bool] = None
-        if 'to_payload' in json:
-            to_payload = bool(json.get("to_payload"))
+        if 'toPayload' in json:
+            to_payload = bool(json.get("toPayload"))
 
         return ForcedNetworkRule(
             inbound,
@@ -134,7 +153,9 @@ class ForcedNetworkRule(object):
             priority,
             description,
             to_qbox,
-            to_payload)
+            to_payload,
+            name,
+            application_type)
 
     def to_json(self):
         result: Dict[str, Union[str, bool]] = {
@@ -142,6 +163,12 @@ class ForcedNetworkRule(object):
             "proto": self.proto,
         }
 
+        if self.name is not None:
+            result["name"] = self.name
+
+        if self.application_type is not None:
+            result["applicationType"] = self.application_type
+
         if self.port is not None:
             result["port"] = self.port
 
@@ -149,10 +176,10 @@ class ForcedNetworkRule(object):
             result["to"] = self.to
 
         if self.public_host is not None:
-            result["public_host"] = self.public_host
+            result["publicHost"] = self.public_host
 
         if self.public_port is not None:
-            result["public_port"] = self.public_port
+            result["publicPort"] = self.public_port
 
         if self.forwarder is not None:
             result["forwarder"] = self.forwarder
@@ -164,9 +191,9 @@ class ForcedNetworkRule(object):
             result["description"] = self.description
 
         if self.to_qbox is not None:
-            result["to_qbox"] = self.to_qbox
+            result["toQBox"] = self.to_qbox
 
         if self.to_payload is not None:
-            result["to_payload"] = self.to_payload
+            result["toPayload"] = self.to_payload
 
         return result

qarnot/multi_slots_settings.py

@@ -0,0 +1,48 @@
+"""Multi Slots Settings that can be used when creating a pool"""
+
+from typing import Dict
+
+
+class MultiSlotsSettings(object):
+    """Represents task multi slots settings."""
+
+    _slotsPerNode: int = None
+
+    def __init__(self, slotsPerNode: int = None):
+        """Create a new :class:`~qarnot.multi_slots_settings.MultiSlotsSettings`.
+
+        :param slotsPerNode: slots per node
+        :type slotsPerNode: int
+        """
+        self._slotsPerNode = slotsPerNode
+
+    @classmethod
+    def from_json(cls, json: Dict[str, int]):
+        """Create the multi slots settings from json.
+
+        :param dict json: Dictionary representing the multi slots settings
+        :returns: The created :class:`~qarnot.multi_slots_settings.MultiSlotsSettings`
+        """
+        slotsPerNode: int = json.get("slotsPerNode")
+        return MultiSlotsSettings(slotsPerNode)
+
+    def to_json(self) -> Dict[str, int]:
+        """Get a dict ready to be json packed.
+
+        :return: the json elements of the class.
+        :rtype: `dict`
+        """
+        return {
+            "slotsPerNode": self._slotsPerNode
+        }
+
+    def __eq__(self, other):
+        if other is None or not isinstance(other, MultiSlotsSettings):
+            return False
+        return self._slotsPerNode == other._slotsPerNode
+
+    def __str__(self) -> str:
+        return "multi slots settings: slotsPerNode {}.".format(self._slotsPerNode)
+
+    def __repr__(self) -> str:
+        return "multi_slots_settings.MultiSlotsSettings(slotsPerNode: {})".format(self._slotsPerNode)

qarnot/pool.py

@@ -19,6 +19,7 @@ from typing import Dict, List, Optional
 
 from qarnot.carbon_facts import CarbonClient, CarbonFacts
 from qarnot.retry_settings import RetrySettings
+from qarnot.multi_slots_settings import MultiSlotsSettings
 from qarnot.forced_network_rule import ForcedNetworkRule
 from qarnot.secrets import SecretsAccessRights
 
@@ -86,6 +87,7 @@ class Pool(object):
         self._update_cache_time = 5
         self._scheduling_type = scheduling_type
         self._targeted_reserved_machine_key: str = None
+        self._targeted_reservation_name: str = None
 
         self._last_cache = time.time()
         self._instancecount = instancecount
@@ -128,6 +130,7 @@ class Pool(object):
         self._default_resources_cache_ttl_sec: Optional[int] = None
         self._privileges: Privileges = Privileges()
         self._default_retry_settings: RetrySettings = RetrySettings()
+        self._multi_slots_settings: Optional[MultiSlotsSettings] = None
         self._forced_network_rules: List[ForcedNetworkRule] = []
         self._secrets_access_rights: SecretsAccessRights = SecretsAccessRights()
 
@@ -238,10 +241,13 @@ class Pool(object):
         self._hardware_constraints = [HardwareConstraint.from_json(hw_constraint_dict) for hw_constraint_dict in json_pool.get("hardwareConstraints", [])]
         self._default_resources_cache_ttl_sec = json_pool.get("defaultResourcesCacheTTLSec", None)
         self._targeted_reserved_machine_key = json_pool.get("targetedReservedMachineKey", None)
+        self._targeted_reservation_name = json_pool.get("targetedReservationName", None)
         if 'privileges' in json_pool:
             self._privileges = Privileges.from_json(json_pool.get("privileges"))
         if 'defaultRetrySettings' in json_pool:
             self._default_retry_settings = RetrySettings.from_json(json_pool.get("defaultRetrySettings"))
+        if 'multiSlotsSettings' in json_pool:
+            self._multi_slots_settings = MultiSlotsSettings.from_json(json_pool.get("multiSlotsSettings"))
         if 'schedulingType' in json_pool:
             self._scheduling_type = SchedulingType.from_string(json_pool.get("schedulingType"))
         self._forced_network_rules = [ForcedNetworkRule.from_json(forced_network_dict) for forced_network_dict in json_pool.get("forcedNetworkRules", [])]
@@ -309,12 +315,18 @@ class Pool(object):
         if self._targeted_reserved_machine_key is not None:
             json_pool['targetedReservedMachineKey'] = self._targeted_reserved_machine_key
 
+        if self._targeted_reservation_name is not None:
+            json_pool['targetedReservationName'] = self._targeted_reservation_name
+
         if self._forced_network_rules is not None:
             json_pool['forcedNetworkRules'] = [x.to_json() for x in self._forced_network_rules]
 
         if self._secrets_access_rights:
             json_pool['secretsAccessRights'] = self._secrets_access_rights.to_json()
 
+        if self._multi_slots_settings:
+            json_pool['multiSlotsSettings'] = self._multi_slots_settings.to_json()
+
         return json_pool
 
     def submit(self):
@@ -1279,6 +1291,24 @@ class Pool(object):
             raise AttributeError("can't set attribute on a submitted job")
         self._completion_time_to_live = _util.parse_to_timespan_string(value)
 
+    @property
+    def multi_slots_settings(self):
+        """
+        :getter:  Returns this pool's multi slots settings.
+        :type: :class:`~qarnot.multi_slots_settings.MultiSlotsSettings`
+        :default_value: None
+        """
+        self._update_if_summary()
+        return self._multi_slots_settings
+
+    @multi_slots_settings.setter
+    def multi_slots_settings(self, value):
+        """Setter for multi_slots_settings, this can only be set before pool's submission"""
+        self._update_if_summary()
+        if self._multi_slots_settings is not None:
+            raise AttributeError("can't set attribute on a submitted pool")
+        self._multi_slots_settings = value
+
     @property
     def previous_state(self):
         """
@@ -1497,6 +1527,9 @@ class Pool(object):
 
         :getter: The reserved machine key when using the "reserved" scheduling type
 
+        .. deprecated:: v2.19.0
+           Use `self.targeted_reservation_name` instead.
+
         :raises AttributeError: trying to set this after the pool is submitted
         """
         return self._targeted_reserved_machine_key
@@ -1510,6 +1543,25 @@ class Pool(object):
 
         self._targeted_reserved_machine_key = value
 
+    @property
+    def targeted_reservation_name(self) -> str:
+        """:type: :class:`str`
+
+        :getter: The name of the reservation that describes the targeted machines when using the "reserved" scheduling type
+
+        :raises AttributeError: trying to set this after the task is submitted
+        """
+        return self._targeted_reservation_name
+
+    @targeted_reservation_name.setter
+    def targeted_reservation_name(self, value: str):
+        """Setted for targeted_reservation_name
+        """
+        if self.uuid is not None:
+            raise AttributeError("can't set attribute on a launched task")
+
+        self._targeted_reservation_name = value
+
     def __repr__(self):
         return '{0} - {1} - {2} - {3} - {5} - InstanceCount : {4} - Resources : {6} '\
             'Tag {7} - IsElastic {8} - ElasticMin {9} - ElasticMax {10} - ElasticMinIdle {11} -'\

qarnot/snapshot.py

@@ -0,0 +1,244 @@
+"""Module to handle snapshot"""
+
+# Copyright 2017 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 datetime import datetime
+from typing import Optional, Dict, Any, Union
+
+
+class SnapshotConfiguration():
+    """Configuration used for a task snapshot"""
+
+    _whitelist: Optional[str] = None
+    _blacklist: Optional[str] = None
+    _bucket_name: Optional[str] = None
+    _bucket_prefix: Optional[str] = None
+
+    def __init__(self,
+                 whitelist: Optional[str] = None,
+                 blacklist: Optional[str] = None,
+                 bucket_name: Optional[str] = None,
+                 bucket_prefix: Optional[str] = None):
+        """The SnapshotConfiguration constructor.
+
+        :param str whitelist: Whitelist filter for the snapshot.
+        :param str blacklist: Blacklist filter for the snapshot.
+        :param str bucket_name: Name of the bucket in which to upload the snapshot.
+        :param str bucket_prefix: Prefix added to the files uploaded for the snapshot.
+        :returns: The created :class:`~qarnot.snapshot.SnapshotConfiguration`.
+        """
+        self._whitelist = whitelist
+        self._blacklist = blacklist
+        self._bucket_name = bucket_name
+        self._bucket_prefix = bucket_prefix
+
+    def to_json(self) -> Dict[str, Optional[Union[str, int]]]:
+        """Get a SnapshotConfiguration ready to be json packed.
+
+        :return: the json representation of a snapshot configuration.
+        :rtype: Dict[str, Optional[str|int]]
+        """
+        return {
+            "whitelist": self._whitelist,
+            "blacklist": self._blacklist,
+            "bucket": self._bucket_name,
+            "bucketPrefix": self._bucket_prefix
+        }
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Optional[str]]):
+        """Create a SnapshotConfiguration from a json representation
+
+        :param json: the json to use to create the SnapshotConfiguration object.
+        :type json: `Dict[str, Optional[str]]`
+        :returns: The created :class:`~qarnot.snapshot.SnapshotConfiguration`.
+        """
+        if json is None:
+            return None
+
+        whitelist = json.get("whitelist")
+        blacklist = json.get("blacklist")
+        bucket_name = json.get("bucket")
+        bucket_prefix = json.get("bucketPrefix")
+
+        return SnapshotConfiguration(whitelist, blacklist, bucket_name, bucket_prefix)
+
+
+class PeriodicSnapshotConfiguration(SnapshotConfiguration):
+    """Configuration used for a task periodic snapshot"""
+    _interval: int = None
+
+    def __init__(self,
+                 interval: int,
+                 whitelist: Optional[str] = None,
+                 blacklist: Optional[str] = None,
+                 bucket_name: Optional[str] = None,
+                 bucket_prefix: Optional[str] = None):
+        """The PeriodicSnapshotConfiguration constructor.
+
+        :param int interval: Interval (in seconds) between two periodic snapshots.
+        :param str whitelist: Whitelist filter for the snapshot.
+        :param str blacklist: Blacklist filter for the snapshot.
+        :param str bucket_name: Bucket where to upload the snapshot.
+        :param str bucket_prefix: Prefix added to the files uploaded for the snapshot.
+        :returns: The created :class:`~qarnot.snapshot.SnapshotConfiguration`.
+        """
+        super().__init__(whitelist, blacklist, bucket_name, bucket_prefix)
+        self._interval = interval
+
+    def to_json(self) -> Dict[str, Optional[Union[str, int]]]:
+        """Get a PeriodicSnapshotConfiguration ready to be json packed.
+
+        :return: the json representation of a periodic snapshot configuration.
+        :rtype: Dict[str, Optional[str|int]]
+        """
+        json: Dict[str, Optional[Union[str, int]]] = super().to_json()
+        json["interval"] = int(self._interval)
+        return json
+
+
+class SnapshotStatus():
+    """Represents a Snapshot of a task."""
+    status: str = None
+    is_completed: bool = False
+
+    @classmethod
+    def from_string(cls, status: str):
+        """Create a snapshot status from string.
+
+        :returns: The created :class:`~qarnot.snapshot.SnapshotStatus`.
+        """
+
+        if status is None:
+            return TriggeredStatus()
+
+        status = str(status)
+
+        if status.lower() == TriggeredStatus.status.lower():
+            return TriggeredStatus()
+        elif status.lower() == InProgressStatus.status.lower():
+            return InProgressStatus()
+        elif status.lower() == SuccessStatus.status.lower():
+            return SuccessStatus()
+        elif status.lower() == FailedStatus.status.lower():
+            return FailedStatus()
+        else:
+            return TriggeredStatus()
+
+    def __str__(self) -> str:
+        return "snapshot status {}.".format(self.status)
+
+    def __repr__(self) -> str:
+        return str(self.status)
+
+
+class TriggeredStatus(SnapshotStatus):
+    """Represents a snapshot triggered status """
+    status: str = "Triggered"
+    is_completed: bool = False
+
+    def __init__(self):
+        """ Create a new snapshot triggered status."""
+
+
+class InProgressStatus(SnapshotStatus):
+    """Represents a snapshot in progress status"""
+    status: str = "InProgress"
+    is_completed: bool = False
+
+    def __init__(self):
+        """ Create a new snapshot in progress status."""
+
+
+class SuccessStatus(SnapshotStatus):
+    """Represents a snapshot success status"""
+    status: str = "Success"
+    is_completed: bool = True
+
+    def __init__(self):
+        """ Create a new snapshot success status."""
+
+
+class FailedStatus(SnapshotStatus):
+    """Represents snapshot failed status"""
+    status: str = "Failure"
+    is_completed: bool = True
+
+    def __init__(self):
+        """ Create a new snapshot failed status."""
+
+
+class Snapshot():
+    """Represents a Snapshot of a task."""
+    _id: str = None
+    _task_uuid: str = None
+    _trigger_date: datetime = None
+    _last_update_date: Optional[datetime] = None
+    _snapshot_config: SnapshotConfiguration = None
+    _status: SnapshotStatus = None
+    _size_to_upload: Optional[int] = None
+    _transferred_size: Optional[int] = None
+
+    def __init__(self,
+                 uid: str = None,
+                 task_uuid: str = None,
+                 trigger_date: datetime = None,
+                 last_update_date: Optional[datetime] = None,
+                 snapshot_config: SnapshotConfiguration = None,
+                 status: SnapshotStatus = None,
+                 size_to_upload: Optional[int] = None,
+                 transferred_size: Optional[int] = None):
+        """The Snapshot constructor.
+
+        :param str uid: identifier of the snapshot.
+        :param str task_uuid: identifier of the task hat have been snapshoted.
+        :param datetime trigger_date: the date (utc) when the snapshot was requested.
+        :param datetime last_update_date: date (utc) of the last update of the current state of the snapshot.
+        :param `~qarnot.snapshot.SnapshotConfiguration` snapshot_config: the filter and output configuration of the snapshot.
+        :param `~qarnot.snapshot.SnapshotStatus` status: Current progress status of the snapshot.
+        :param int size_to_upload: total size (in bytes) expected to upload for the snapshot.
+        :param int transferred_size: current size (in bytes) of the upload for the snapshot.
+        :returns: The created :class:`~qarnot.snapshot.Snapshot`.
+        """
+        self._id = uid
+        self._task_uuid = task_uuid
+        self._trigger_date = trigger_date
+        self._last_update_date = last_update_date
+        self._snapshot_config = snapshot_config
+        self._status = status
+        self._size_to_upload = size_to_upload
+        self._transferred_size = transferred_size
+
+    @classmethod
+    def from_json(cls, json: Dict[str, Any]):
+        """Create a Snapshot from a json representation
+
+        :param json: the json to use to create the Snapshot object.
+        :type json: `Dict[str, Any]`
+        :returns: The created :class:`~qarnot.snapshot.Snapshot`.
+        """
+        if json is None:
+            return None
+
+        uid = json.get("id")
+        task_uuid = json.get("taskUuid")
+        trigger_date = json.get("triggerDate")
+        last_update_date = json.get("lastUpdateDate")
+        snapshot_config = SnapshotConfiguration.from_json(json.get("snapshotConfig"))
+        status = SnapshotStatus.from_string(json.get("status"))
+        size_to_upload = json.get("sizeToUpload")
+        transferred_size = json.get("transferredSize")
+
+        return Snapshot(uid, task_uuid, trigger_date, last_update_date, snapshot_config, status, size_to_upload, transferred_size)

qarnot/task.py

@@ -31,6 +31,7 @@ from .status import Status
 from .hardware_constraint import HardwareConstraint
 from .forced_constant import ForcedConstant
 from .scheduling_type import SchedulingType
+from .snapshot import SnapshotConfiguration, PeriodicSnapshotConfiguration, Snapshot
 from .privileges import Privileges
 from .bucket import Bucket
 from .pool import Pool
@@ -132,6 +133,7 @@ class Task(object):
         self._secrets_access_rights: SecretsAccessRights = SecretsAccessRights()
         self._scheduling_type = scheduling_type
         self._targeted_reserved_machine_key: str = None
+        self._targeted_reservation_name: str = None
         self._dependentOn: List[Uuid] = []
 
         self._auto_update = True
@@ -521,6 +523,7 @@ class Task(object):
         self._hardware_constraints = [HardwareConstraint.from_json(hw_constraint_dict) for hw_constraint_dict in json_task.get("hardwareConstraints", [])]
         self._default_resources_cache_ttl_sec = json_task.get("defaultResourcesCacheTTLSec", None)
         self._targeted_reserved_machine_key = json_task.get("targetedReservedMachineKey", None)
+        self._targeted_reservation_name = json_task.get("targetedReservationName", None)
         if 'privileges' in json_task:
             self._privileges = Privileges.from_json(json_task.get("privileges"))
         if 'retrySettings' in json_task:
@@ -661,7 +664,7 @@ class Task(object):
 
         return self.state
 
-    def snapshot(self, interval: int) -> None:
+    def snapshot(self, interval: int, whitelist: Optional[str] = None, blacklist: Optional[str] = None, bucket: BucketType = None, bucket_prefix: Optional[str] = None) -> None:
         """Start snapshooting results.
         If called, this task's results will be periodically
         updated, instead of only being available at the end.
@@ -670,6 +673,10 @@ class Task(object):
         the task is submitted.
 
         :param int interval: the interval in seconds at which to take snapshots
+        :param str whitelist: whitelist filter for the snapshot.
+        :param str blacklist: blacklist filter for the snapshot.
+        :param ~qarnot.bucket.Bucket bucket: bucket to upload the snapshot.
+        :param str bucket_prefix: prefix added to the files uploaded for the snapshot.
 
         :raises ~qarnot.exceptions.QarnotGenericException: API general error, see message for details
         :raises ~qarnot.exceptions.UnauthorizedException: invalid credentials
@@ -683,8 +690,10 @@ class Task(object):
         if self._uuid is None:
             self._snapshots = interval
             return
+
+        snapshot_config = PeriodicSnapshotConfiguration(interval, whitelist, blacklist, bucket, bucket_prefix)
         resp = self._connection._post(get_url('task snapshot', uuid=self._uuid),
-                                      json={"interval": interval})
+                                      json=snapshot_config.to_json())
 
         if resp.status_code == 400:
             raise ValueError(interval)
@@ -697,8 +706,13 @@ class Task(object):
 
         self._snapshots = True
 
-    def instant(self) -> None:
-        """Make a snapshot of the current task.
+    def instant(self, whitelist: Optional[str] = None, blacklist: Optional[str] = None, bucket: BucketType = None, bucket_prefix: Optional[str] = None) -> str:
+        """Make an instant snapshot of the current task.
+
+        :param str whitelist: Whitelist filter for the snapshot.
+        :param str blacklist: Blacklist filter for the snapshot.
+        :param ~qarnot.bucket.Bucket bucket: bucket where to upload the snapshot.
+        :param str bucket_prefix: Prefix added to the files uploaded for the snapshot.
 
         :raises ~qarnot.exceptions.QarnotGenericException: API general error, see message for details
         :raises ~qarnot.exceptions.UnauthorizedException: invalid credentials
@@ -708,10 +722,13 @@ class Task(object):
         .. note:: To get the temporary results, call :meth:`download_results`.
         """
         if self._uuid is None:
-            return
+            return None
+
+        bucket_name = (bucket.uuid if bucket is not None else None)
+        snapshot_config = SnapshotConfiguration(whitelist, blacklist, bucket_name, bucket_prefix)
 
         resp = self._connection._post(get_url('task instant', uuid=self._uuid),
-                                      json=None)
+                                      json=snapshot_config.to_json())
 
         if resp.status_code == 404:
             raise MissingTaskException(_util.get_error_message_from_http_response(resp))
@@ -720,6 +737,80 @@ class Task(object):
         raise_on_error(resp)
 
         self.update(True)
+        return resp.json().get("id")
+
+    def snapshot_status(self, snapshot_id: str) -> Snapshot:
+        """Get the status of a specific instant snapshot.
+
+        :param str snapshot_id: id of the instant snapshot we want the status.
+
+        :raises ~qarnot.exceptions.QarnotGenericException: API general error, see message for details
+        :raises ~qarnot.exceptions.UnauthorizedException: invalid credentials
+        :raises ~qarnot.exceptions.UnauthorizedException: invalid operation on non running task
+        :raises ~qarnot.exceptions.MissingTaskException: task does not exist
+
+        .. note:: To get the temporary results, call :meth:`download_results`.
+        """
+        if self._uuid is None:
+            return None
+
+        resp = self._connection._get(get_url('task instant status', uuid=self._uuid, snapshotId=snapshot_id),
+                                     json=None)
+
+        if resp.status_code == 404:
+            raise MissingTaskException(_util.get_error_message_from_http_response(resp))
+        elif resp.status_code == 403:
+            raise UnauthorizedException(_util.get_error_message_from_http_response(resp))
+        raise_on_error(resp)
+
+        return Snapshot.from_json(resp.json())
+
+    def wait_snapshot(self, snapshot_id: str, timeout: float = None, follow_status: bool = False) -> bool:
+        """Wait for the task snapshot to complete.
+
+        :param float timeout: maximum time (in seconds) to wait before returning
+           (None => no timeout)
+
+        :rtype: :class:`bool`
+        :returns: Is the snapshot finished
+
+        :raises ~qarnot.exceptions.QarnotGenericException: API general error, see message for details
+        :raises ~qarnot.exceptions.UnauthorizedException: invalid credentials
+        :raises ~qarnot.exceptions.MissingTaskException: task does not represent a valid
+          one
+        """
+
+        start = time.time()
+        if self._uuid is None:
+            self.update(True)
+            return False
+
+        if snapshot_id is None or snapshot_id == "":
+            return False
+
+        nap = min(10, timeout) if timeout is not None else 10
+
+        last_status = None
+        snapshot_status = self.snapshot_status(snapshot_id=snapshot_id)
+        if snapshot_status is None:
+            return False
+
+        while snapshot_status is None or not snapshot_status._status.is_completed:
+            time.sleep(nap)
+            snapshot_status = self.snapshot_status(snapshot_id)
+            if follow_status:
+                if snapshot_status._status.status != last_status:
+                    last_status = snapshot_status._status.status
+                    self._connection.logger.info("** Snapshot %s Status| %s" % (snapshot_id, last_status))
+
+            if timeout is not None:
+                elapsed = time.time() - start
+                if timeout <= elapsed:
+                    self.update()
+                    return False
+                else:
+                    nap = min(10, timeout - elapsed)
+        return True
 
     @property
     def state(self):
@@ -1641,6 +1732,9 @@ class Task(object):
 
         :getter: The reserved machine key when using the "reserved" scheduling type
 
+        .. deprecated:: v2.19.0
+           Use `self.targeted_reservation_name` instead.
+
         :raises AttributeError: trying to set this after the task is submitted
         """
         return self._targeted_reserved_machine_key
@@ -1654,6 +1748,25 @@ class Task(object):
 
         self._targeted_reserved_machine_key = value
 
+    @property
+    def targeted_reservation_name(self) -> str:
+        """:type: :class:`str`
+
+        :getter: The name of the reservation that describes the targeted machines when using the "reserved" scheduling type
+
+        :raises AttributeError: trying to set this after the task is submitted
+        """
+        return self._targeted_reservation_name
+
+    @targeted_reservation_name.setter
+    def targeted_reservation_name(self, value: str):
+        """Setted for targeted_reservation_name
+        """
+        if self.uuid is not None:
+            raise AttributeError("can't set attribute on a launched task")
+
+        self._targeted_reservation_name = value
+
     @property
     def auto_delete(self):
         """Autodelete this Task if it is finished and your max number of task is reach
@@ -1892,6 +2005,9 @@ class Task(object):
         if self._targeted_reserved_machine_key is not None:
             json_task["targetedReservedMachineKey"] = self._targeted_reserved_machine_key
 
+        if self._targeted_reservation_name is not None:
+            json_task["targetedReservationName"] = self._targeted_reservation_name
+
         if self._forced_network_rules is not None:
             json_task['forcedNetworkRules'] = [x.to_json() for x in self._forced_network_rules]
 

{qarnot-2.18.0.dist-info → qarnot-2.20.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qarnot
-Version: 2.18.0
+Version: 2.20.1
 Summary: Qarnot Computing SDK
 Home-page: https://computing.qarnot.com
 Author: Qarnot computing

{qarnot-2.18.0.dist-info → qarnot-2.20.1.dist-info}/RECORD

@@ -1,31 +1,33 @@
-qarnot/__init__.py,sha256=BCIFvWIe1EbzdZAMeKnyK9HYIqNHlSsbaaDMIL7VghA,5626
+qarnot/__init__.py,sha256=9YYIJJ1Y-PjWXnOBq7z04IocK_OskerJxc-2mOBI5qY,5728
 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=7tz02m0CSFBqrG9O7MBXuCGhUSa4292fCRUFrZqcSI4,499
+qarnot/_version.py,sha256=tYo4IXXQVfmjbR_GHcGEdgj4ocZabWCvPK6yI4dAjKM,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/computing_quotas.py,sha256=qK-aJFKKi8TGarQ_QX2rM4rjDsg3iMV__hgxikIgNy0,15418
+qarnot/computing_quotas.py,sha256=gXKAZ1QqnXGzR17yTYNmjDF1TBEXALtCHzEe51wk4to,15882
 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/forced_network_rule.py,sha256=gAalmj5p3MDXEG_jRfszhUTpOSKDMH_BFiXDuSnnyOc,5306
 qarnot/hardware_constraint.py,sha256=YZi4FgaJQ84mxVDT4u2WxqJ-i_bikwssidTRHRc3JHA,13694
 qarnot/helper.py,sha256=HWy0ollEMoGvCXbAY_FfgkhJjpHRRmkNtavvrJba2PY,1564
 qarnot/job.py,sha256=bag9NbugWCSf18J2c6nFKmWFFusXP58dfYYxd8CMsy8,19508
+qarnot/multi_slots_settings.py,sha256=RsSC-3YGu0wBsQlOgvJ8oMKFvApN6XEGdC5ozgQyXXs,1542
 qarnot/paginate.py,sha256=DaUYDPAS0M8hf0hph8GuMSzTASymSUOpp-WqbfevX-s,1387
-qarnot/pool.py,sha256=dUSOOkuFhNyR3Yr07svLKNBlzITddyoJR1wOtmKgpxA,57033
+qarnot/pool.py,sha256=IaRYjCamrLHm9BWpjDmbxRhNIjb8f7m88wDIi6gGRa8,59165
 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/snapshot.py,sha256=S8YZDSlzngmBHjmditkZQdrHWiO0nozXbP8y_zMsrV4,9137
 qarnot/status.py,sha256=dCVsh9_ewIASZcreATbUd2qJ-cUMk0cRkyVLdrOot3Q,12348
 qarnot/storage.py,sha256=jAist_J_6yzmRrkF5jqYNG3mhEP_y7KqCdNv4dJcHuM,6929
-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/task.py,sha256=LQYslV90T4rpo76sPUqG2IhpIMu19QJtI5Jp7jCvJCI,81443
+qarnot-2.20.1.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+qarnot-2.20.1.dist-info/METADATA,sha256=YjtHFPdEP7SHgv5zsdAMFNQmc4vvB-aU8RRUco-8xNk,2543
+qarnot-2.20.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+qarnot-2.20.1.dist-info/top_level.txt,sha256=acRyoLZNyf_kuGTwHQgfZv2MfdTcZstyNjBhOxFtHzU,7
+qarnot-2.20.1.dist-info/RECORD,,

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

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