gamsapi 52.5.0__cp312-cp312-win_amd64.whl

gams/engine/models/hypercube_summary.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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HypercubeSummary(BaseModel):
+    """
+    HypercubeSummary
+    """ # noqa: E501
+    finished: Optional[StrictInt] = None
+    finished_with_status_code_zero: Optional[StrictInt] = None
+    job_count: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["finished", "finished_with_status_code_zero", "job_count"]
+
+    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 HypercubeSummary 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 HypercubeSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "finished": obj.get("finished"),
+            "finished_with_status_code_zero": obj.get("finished_with_status_code_zero"),
+            "job_count": obj.get("job_count")
+        })
+        return _obj
+
+

gams/engine/models/hypercube_token.py

@@ -0,0 +1,97 @@
+# 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.quota import Quota
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HypercubeToken(BaseModel):
+    """
+    HypercubeToken
+    """ # noqa: E501
+    hypercube_token: Optional[StrictStr] = None
+    quota_warning: Optional[List[Quota]] = None
+    __properties: ClassVar[List[str]] = ["hypercube_token", "quota_warning"]
+
+    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 HypercubeToken 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 quota_warning (list)
+        _items = []
+        if self.quota_warning:
+            for _item_quota_warning in self.quota_warning:
+                if _item_quota_warning:
+                    _items.append(_item_quota_warning.to_dict())
+            _dict['quota_warning'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of HypercubeToken from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "hypercube_token": obj.get("hypercube_token"),
+            "quota_warning": [Quota.from_dict(_item) for _item in obj["quota_warning"]] if obj.get("quota_warning") is not None else None
+        })
+        return _obj
+
+

gams/engine/models/identity_provider.py

@@ -0,0 +1,107 @@
+# 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 gams.engine.models.identity_provider_oauth2 import IdentityProviderOauth2
+from gams.engine.models.identity_provider_oidc import IdentityProviderOidc
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IdentityProvider(BaseModel):
+    """
+    IdentityProvider
+    """ # noqa: E501
+    hidden: Optional[StrictBool] = None
+    is_ldap_identity_provider: Optional[StrictBool] = None
+    is_main_identity_provider: Optional[StrictBool] = None
+    label: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
+    oauth2: Optional[IdentityProviderOauth2] = None
+    oidc: Optional[IdentityProviderOidc] = None
+    __properties: ClassVar[List[str]] = ["hidden", "is_ldap_identity_provider", "is_main_identity_provider", "label", "name", "oauth2", "oidc"]
+
+    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 IdentityProvider 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 oauth2
+        if self.oauth2:
+            _dict['oauth2'] = self.oauth2.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of oidc
+        if self.oidc:
+            _dict['oidc'] = self.oidc.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IdentityProvider from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "hidden": obj.get("hidden"),
+            "is_ldap_identity_provider": obj.get("is_ldap_identity_provider"),
+            "is_main_identity_provider": obj.get("is_main_identity_provider"),
+            "label": obj.get("label"),
+            "name": obj.get("name"),
+            "oauth2": IdentityProviderOauth2.from_dict(obj["oauth2"]) if obj.get("oauth2") is not None else None,
+            "oidc": IdentityProviderOidc.from_dict(obj["oidc"]) if obj.get("oidc") is not None else None
+        })
+        return _obj
+
+

gams/engine/models/identity_provider_ldap.py

@@ -0,0 +1,121 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IdentityProviderLdap(BaseModel):
+    """
+    IdentityProviderLdap
+    """ # noqa: E501
+    active_directory: Optional[StrictBool] = None
+    base: Optional[StrictStr] = None
+    bind_dn: Optional[StrictStr] = None
+    encryption: Optional[StrictStr] = None
+    hidden: Optional[StrictBool] = None
+    host: Optional[StrictStr] = None
+    label: Optional[StrictStr] = None
+    name: Optional[StrictStr] = None
+    password: Optional[StrictStr] = None
+    port: Optional[StrictInt] = None
+    uid: Optional[StrictStr] = None
+    user_filter: Optional[StrictStr] = None
+    verify_certificates: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["active_directory", "base", "bind_dn", "encryption", "hidden", "host", "label", "name", "password", "port", "uid", "user_filter", "verify_certificates"]
+
+    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 IdentityProviderLdap 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 bind_dn (nullable) is None
+        # and model_fields_set contains the field
+        if self.bind_dn is None and "bind_dn" in self.model_fields_set:
+            _dict['bind_dn'] = None
+
+        # set to None if password (nullable) is None
+        # and model_fields_set contains the field
+        if self.password is None and "password" in self.model_fields_set:
+            _dict['password'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IdentityProviderLdap from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "active_directory": obj.get("active_directory"),
+            "base": obj.get("base"),
+            "bind_dn": obj.get("bind_dn"),
+            "encryption": obj.get("encryption"),
+            "hidden": obj.get("hidden"),
+            "host": obj.get("host"),
+            "label": obj.get("label"),
+            "name": obj.get("name"),
+            "password": obj.get("password"),
+            "port": obj.get("port"),
+            "uid": obj.get("uid"),
+            "user_filter": obj.get("user_filter"),
+            "verify_certificates": obj.get("verify_certificates")
+        })
+        return _obj
+
+

gams/engine/models/identity_provider_oauth2.py

@@ -0,0 +1,146 @@
+# 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 gams.engine.models.identity_provider_oauth2_scope import IdentityProviderOauth2Scope
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IdentityProviderOauth2(BaseModel):
+    """
+    IdentityProviderOauth2
+    """ # noqa: E501
+    authorization_endpoint: Optional[StrictStr] = None
+    device_authorization_endpoint: Optional[StrictStr] = None
+    device_client_id: Optional[StrictStr] = None
+    end_session_endpoint: Optional[StrictStr] = None
+    grant_types_supported: Optional[List[StrictStr]] = None
+    has_web_ui_client_secret: Optional[StrictBool] = None
+    issuer: Optional[StrictStr] = None
+    jwks_uri: Optional[StrictStr] = None
+    override_audience: Optional[StrictStr] = None
+    response_types_supported: Optional[List[StrictStr]] = None
+    scopes: Optional[List[IdentityProviderOauth2Scope]] = None
+    token_endpoint: Optional[StrictStr] = None
+    token_endpoint_auth_methods_supported: Optional[List[StrictStr]] = None
+    web_ui_client_id: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["authorization_endpoint", "device_authorization_endpoint", "device_client_id", "end_session_endpoint", "grant_types_supported", "has_web_ui_client_secret", "issuer", "jwks_uri", "override_audience", "response_types_supported", "scopes", "token_endpoint", "token_endpoint_auth_methods_supported", "web_ui_client_id"]
+
+    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 IdentityProviderOauth2 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 scopes (list)
+        _items = []
+        if self.scopes:
+            for _item_scopes in self.scopes:
+                if _item_scopes:
+                    _items.append(_item_scopes.to_dict())
+            _dict['scopes'] = _items
+        # set to None if device_authorization_endpoint (nullable) is None
+        # and model_fields_set contains the field
+        if self.device_authorization_endpoint is None and "device_authorization_endpoint" in self.model_fields_set:
+            _dict['device_authorization_endpoint'] = None
+
+        # set to None if device_client_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.device_client_id is None and "device_client_id" in self.model_fields_set:
+            _dict['device_client_id'] = None
+
+        # set to None if end_session_endpoint (nullable) is None
+        # and model_fields_set contains the field
+        if self.end_session_endpoint is None and "end_session_endpoint" in self.model_fields_set:
+            _dict['end_session_endpoint'] = None
+
+        # set to None if override_audience (nullable) is None
+        # and model_fields_set contains the field
+        if self.override_audience is None and "override_audience" in self.model_fields_set:
+            _dict['override_audience'] = None
+
+        # set to None if token_endpoint (nullable) is None
+        # and model_fields_set contains the field
+        if self.token_endpoint is None and "token_endpoint" in self.model_fields_set:
+            _dict['token_endpoint'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IdentityProviderOauth2 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "authorization_endpoint": obj.get("authorization_endpoint"),
+            "device_authorization_endpoint": obj.get("device_authorization_endpoint"),
+            "device_client_id": obj.get("device_client_id"),
+            "end_session_endpoint": obj.get("end_session_endpoint"),
+            "grant_types_supported": obj.get("grant_types_supported"),
+            "has_web_ui_client_secret": obj.get("has_web_ui_client_secret"),
+            "issuer": obj.get("issuer"),
+            "jwks_uri": obj.get("jwks_uri"),
+            "override_audience": obj.get("override_audience"),
+            "response_types_supported": obj.get("response_types_supported"),
+            "scopes": [IdentityProviderOauth2Scope.from_dict(_item) for _item in obj["scopes"]] if obj.get("scopes") is not None else None,
+            "token_endpoint": obj.get("token_endpoint"),
+            "token_endpoint_auth_methods_supported": obj.get("token_endpoint_auth_methods_supported"),
+            "web_ui_client_id": obj.get("web_ui_client_id")
+        })
+        return _obj
+
+

gams/engine/models/identity_provider_oauth2_scope.py

@@ -0,0 +1,89 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+
+class IdentityProviderOauth2Scope(BaseModel):
+    """
+    IdentityProviderOauth2Scope
+    """ # noqa: E501
+    request_scope: Optional[StrictStr] = None
+    scope: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["request_scope", "scope"]
+
+    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 IdentityProviderOauth2Scope 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 IdentityProviderOauth2Scope from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "request_scope": obj.get("request_scope"),
+            "scope": obj.get("scope")
+        })
+        return _obj
+
+