qarnot 2.17.0__tar.gz → 2.19.0__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: qarnot
-Version: 2.17.0
+Version: 2.19.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.19.0}/doc/source/api/compute/computeindex.rst

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

qarnot-2.19.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.19.0}/qarnot/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-05T10:05:53+0100",
+ "date": "2025-09-04T17:06:17+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "559a43baceed056873c5b9dab07d987025306be8",
- "version": "v2.17.0"
+ "full-revisionid": "2436d80006a87be548b2235b12f0a6f041ef66c1",
+ "version": "v2.19.0"
 }
 '''  # END VERSION_JSON
 

qarnot-2.19.0/qarnot/computing_quotas.py

@@ -0,0 +1,340 @@
+# 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, 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.
+        :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.
+        """
+        self.reservation_name = reservation_name
+        """:type: :class:`str`
+
+        Name 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('reservationName'),
+            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 json.get('reserved') is not None else []) 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, 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.
+        :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.
+        """
+        self.reservation_name = reservation_name
+        """:type: :class:`str`
+
+        Name 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('reservationName'),
+            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 json.get('reserved') is not None else []) 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.19.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.19.0}/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-2.17.0 → qarnot-2.19.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.19.0/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)