gamsapi 52.5.0__cp312-cp312-win_amd64.whl

gams/engine/models/model_user.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelUser(BaseModel):
+    """
+    ModelUser
+    """ # noqa: E501
+    deleted: Optional[StrictBool] = None
+    old_username: Optional[StrictStr] = None
+    username: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["deleted", "old_username", "username"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ModelUser from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if old_username (nullable) is None
+        # and model_fields_set contains the field
+        if self.old_username is None and "old_username" in self.model_fields_set:
+            _dict['old_username'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ModelUser from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "deleted": obj.get("deleted"),
+            "old_username": obj.get("old_username"),
+            "username": obj.get("username")
+        })
+        return _obj
+
+

gams/engine/models/model_userinstance_info.py

@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from gams.engine.models.model_instance_info import ModelInstanceInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelUserinstanceInfo(BaseModel):
+    """
+    ModelUserinstanceInfo
+    """ # noqa: E501
+    default_inherited_from: Optional[StrictStr] = None
+    default_instance: Optional[ModelInstanceInfo] = None
+    instances_available: Optional[List[Optional[ModelInstanceInfo]]] = None
+    instances_inherited_from: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["default_inherited_from", "default_instance", "instances_available", "instances_inherited_from"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ModelUserinstanceInfo from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of default_instance
+        if self.default_instance:
+            _dict['default_instance'] = self.default_instance.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in instances_available (list)
+        _items = []
+        if self.instances_available:
+            for _item_instances_available in self.instances_available:
+                if _item_instances_available:
+                    _items.append(_item_instances_available.to_dict())
+            _dict['instances_available'] = _items
+        # set to None if default_inherited_from (nullable) is None
+        # and model_fields_set contains the field
+        if self.default_inherited_from is None and "default_inherited_from" in self.model_fields_set:
+            _dict['default_inherited_from'] = None
+
+        # set to None if default_instance (nullable) is None
+        # and model_fields_set contains the field
+        if self.default_instance is None and "default_instance" in self.model_fields_set:
+            _dict['default_instance'] = None
+
+        # set to None if instances_inherited_from (nullable) is None
+        # and model_fields_set contains the field
+        if self.instances_inherited_from is None and "instances_inherited_from" in self.model_fields_set:
+            _dict['instances_inherited_from'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ModelUserinstanceInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "default_inherited_from": obj.get("default_inherited_from"),
+            "default_instance": ModelInstanceInfo.from_dict(obj["default_instance"]) if obj.get("default_instance") is not None else None,
+            "instances_available": [ModelInstanceInfo.from_dict(_item) for _item in obj["instances_available"]] if obj.get("instances_available") is not None else None,
+            "instances_inherited_from": obj.get("instances_inherited_from")
+        })
+        return _obj
+
+

gams/engine/models/model_userinstancepool_info.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from gams.engine.models.model_instance_pool_info import ModelInstancePoolInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelUserinstancepoolInfo(BaseModel):
+    """
+    ModelUserinstancepoolInfo
+    """ # noqa: E501
+    instance_pools_available: Optional[List[ModelInstancePoolInfo]] = None
+    __properties: ClassVar[List[str]] = ["instance_pools_available"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ModelUserinstancepoolInfo from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in instance_pools_available (list)
+        _items = []
+        if self.instance_pools_available:
+            for _item_instance_pools_available in self.instance_pools_available:
+                if _item_instance_pools_available:
+                    _items.append(_item_instance_pools_available.to_dict())
+            _dict['instance_pools_available'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ModelUserinstancepoolInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "instance_pools_available": [ModelInstancePoolInfo.from_dict(_item) for _item in obj["instance_pools_available"]] if obj.get("instance_pools_available") is not None else None
+        })
+        return _obj
+
+

gams/engine/models/model_version.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ModelVersion(BaseModel):
+    """
+    ModelVersion
+    """ # noqa: E501
+    gams_version: Optional[StrictStr] = None
+    in_kubernetes: Optional[StrictBool] = None
+    version: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["gams_version", "in_kubernetes", "version"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ModelVersion from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ModelVersion from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "gams_version": obj.get("gams_version"),
+            "in_kubernetes": obj.get("in_kubernetes"),
+            "version": obj.get("version")
+        })
+        return _obj
+
+

gams/engine/models/models.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from gams.engine.models.inex import Inex
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Models(BaseModel):
+    """
+    Models
+    """ # noqa: E501
+    arguments: Optional[List[StrictStr]] = None
+    inex: Optional[Inex] = None
+    length: Optional[StrictInt] = None
+    name: Optional[StrictStr] = None
+    protect_model_files: Optional[StrictBool] = False
+    run: Optional[StrictStr] = None
+    stream_entries: Optional[List[StrictStr]] = None
+    text_entries: Optional[List[StrictStr]] = None
+    upload_date: Optional[datetime] = None
+    user_groups: Optional[List[StrictStr]] = None
+    __properties: ClassVar[List[str]] = ["arguments", "inex", "length", "name", "protect_model_files", "run", "stream_entries", "text_entries", "upload_date", "user_groups"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Models from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of inex
+        if self.inex:
+            _dict['inex'] = self.inex.to_dict()
+        # set to None if inex (nullable) is None
+        # and model_fields_set contains the field
+        if self.inex is None and "inex" in self.model_fields_set:
+            _dict['inex'] = None
+
+        # set to None if run (nullable) is None
+        # and model_fields_set contains the field
+        if self.run is None and "run" in self.model_fields_set:
+            _dict['run'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Models from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "arguments": obj.get("arguments"),
+            "inex": Inex.from_dict(obj["inex"]) if obj.get("inex") is not None else None,
+            "length": obj.get("length"),
+            "name": obj.get("name"),
+            "protect_model_files": obj.get("protect_model_files") if obj.get("protect_model_files") is not None else False,
+            "run": obj.get("run"),
+            "stream_entries": obj.get("stream_entries"),
+            "text_entries": obj.get("text_entries"),
+            "upload_date": obj.get("upload_date"),
+            "user_groups": obj.get("user_groups")
+        })
+        return _obj
+
+

gams/engine/models/namespace.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    GAMS Engine
+
+    With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
+
+    The version of the OpenAPI document: latest
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from gams.engine.models.perm_and_username import PermAndUsername
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Namespace(BaseModel):
+    """
+    Namespace
+    """ # noqa: E501
+    disk_quota: Optional[StrictInt] = None
+    name: Optional[StrictStr] = None
+    permissions: Optional[List[PermAndUsername]] = None
+    __properties: ClassVar[List[str]] = ["disk_quota", "name", "permissions"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Namespace from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in permissions (list)
+        _items = []
+        if self.permissions:
+            for _item_permissions in self.permissions:
+                if _item_permissions:
+                    _items.append(_item_permissions.to_dict())
+            _dict['permissions'] = _items
+        # set to None if disk_quota (nullable) is None
+        # and model_fields_set contains the field
+        if self.disk_quota is None and "disk_quota" in self.model_fields_set:
+            _dict['disk_quota'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Namespace from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "disk_quota": obj.get("disk_quota"),
+            "name": obj.get("name"),
+            "permissions": [PermAndUsername.from_dict(_item) for _item in obj["permissions"]] if obj.get("permissions") is not None else None
+        })
+        return _obj
+
+