stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/configuration.py

@@ -0,0 +1,164 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import sys
+from typing import Dict, List, Optional, TypedDict
+
+from typing_extensions import NotRequired
+
+import os
+
+
+ServerVariablesT = Dict[str, str]
+
+
+class HostSettingVariable(TypedDict):
+    description: str
+    default_value: str
+    enum_values: List[str]
+
+
+class HostSetting(TypedDict):
+    url: str
+    description: str
+    variables: NotRequired[Dict[str, HostSettingVariable]]
+
+
+class HostConfiguration:
+    def __init__(
+        self,
+        region=None,
+        server_index=None,
+        server_variables=None,
+        server_operation_index=None,
+        server_operation_variables=None,
+        ignore_operation_servers=False,
+    ) -> None:
+        print(
+            "WARNING: STACKIT will move to a new way of specifying regions, where the region is provided\n",
+            "as a function argument instead of being set in the client configuration.\n"
+            "Once all services have migrated, the methods to specify the region in the client configuration "
+            "will be removed.",
+            file=sys.stderr,
+        )
+        """Constructor
+        """
+        self._base_path = "https://vpn.api.eu01.stackit.cloud"
+        """Default Base url
+        """
+        self.server_index = 0 if server_index is None else server_index
+        self.server_operation_index = server_operation_index or {}
+        """Default server index
+        """
+        self.server_variables = server_variables or {}
+        if region:
+            self.server_variables["region"] = "{}.".format(region)
+        self.server_operation_variables = server_operation_variables or {}
+        """Default server variables
+        """
+        self.ignore_operation_servers = ignore_operation_servers
+        """Ignore operation servers
+        """
+
+    def get_host_settings(self) -> List[HostSetting]:
+        """Gets an array of host settings
+
+        :return: An array of host settings
+        """
+        return [
+            {
+                "url": "https://vpn.api.{region}stackit.cloud",
+                "description": "No description provided",
+                "variables": {
+                    "region": {
+                        "description": "No description provided",
+                        "default_value": "eu01.",
+                        "enum_values": ["eu01."],
+                    }
+                },
+            }
+        ]
+
+    def get_host_from_settings(
+        self,
+        index: Optional[int],
+        variables: Optional[ServerVariablesT] = None,
+        servers: Optional[List[HostSetting]] = None,
+    ) -> str:
+        """Gets host URL based on the index and variables
+        :param index: array index of the host settings
+        :param variables: hash of variable and the corresponding value
+        :param servers: an array of host settings or None
+        :error: if a region is given for a global url
+        :return: URL based on host settings
+        """
+        if index is None:
+            return self._base_path
+
+        variables = {} if variables is None else variables
+        servers = self.get_host_settings() if servers is None else servers
+
+        try:
+            server = servers[index]
+        except IndexError:
+            raise ValueError(
+                "Invalid index {0} when selecting the host settings. "
+                "Must be less than {1}".format(index, len(servers))
+            )
+
+        url = server["url"]
+
+        # check if environment variable was provided for region
+        # if nothing was set this is None
+        region_env = os.environ.get("STACKIT_REGION")
+
+        # go through variables and replace placeholders
+        for variable_name, variable in server.get("variables", {}).items():
+            # If a region is provided by the user for a global url
+            # return an error (except for providing via environment variable).
+            # The region is provided as a function argument instead of being set in the client configuration.
+            if (
+                variable_name == "region"
+                and (variable["default_value"] == "global" or variable["default_value"] == "")
+                and region_env is None
+                and variables.get(variable_name) is not None
+            ):
+                raise ValueError(
+                    "this API does not support setting a region in the client configuration, "
+                    "please check if the region can be specified as a function parameter"
+                )
+            used_value = variables.get(variable_name, variable["default_value"])
+
+            if "enum_values" in variable and used_value not in variable["enum_values"]:
+                given_value = variables[variable_name].replace(".", "")
+                valid_values = [v.replace(".", "") for v in variable["enum_values"]]
+                raise ValueError(
+                    "The variable `{0}` in the host URL has invalid value '{1}'. Must be '{2}'.".format(
+                        variable_name, given_value, valid_values
+                    )
+                )
+
+            url = url.replace("{" + variable_name + "}", used_value)
+
+        return url
+
+    @property
+    def host(self) -> str:
+        """Return generated host."""
+        return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+    @host.setter
+    def host(self, value: str) -> None:
+        """Fix base path."""
+        self._base_path = value
+        self.server_index = None

src/stackit/vpn/exceptions.py

@@ -0,0 +1,217 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from typing import Any, Optional
+
+from typing_extensions import Self
+
+
+class OpenApiException(Exception):
+    """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+    def __init__(self, msg, path_to_item=None, valid_classes=None, key_type=None) -> None:
+        """Raises an exception for TypeErrors
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list): a list of keys an indices to get to the
+                                 current_item
+                                 None if unset
+            valid_classes (tuple): the primitive classes that current item
+                                   should be an instance of
+                                   None if unset
+            key_type (bool): False if our value is a value in a dict
+                             True if it is a key in a dict
+                             False if our item is an item in a list
+                             None if unset
+        """
+        self.path_to_item = path_to_item
+        self.valid_classes = valid_classes
+        self.key_type = key_type
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list) the path to the exception in the
+                received_data dict. None if unset
+        """
+
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Raised when an attribute reference or assignment fails.
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+    def __init__(
+        self,
+        status=None,
+        reason=None,
+        http_resp=None,
+        *,
+        body: Optional[str] = None,
+        data: Optional[Any] = None,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+        self.data = data
+        self.headers = None
+
+        if http_resp:
+            if self.status is None:
+                self.status = http_resp.status
+            if self.reason is None:
+                self.reason = http_resp.reason
+            if self.body is None:
+                try:
+                    self.body = http_resp.data.decode("utf-8")
+                except Exception:  # noqa: S110
+                    pass
+            self.headers = http_resp.headers
+
+    @classmethod
+    def from_response(
+        cls,
+        *,
+        http_resp,
+        body: Optional[str],
+        data: Optional[Any],
+    ) -> Self:
+        if http_resp.status == 400:
+            raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 401:
+            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 403:
+            raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 404:
+            raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+        # Added new conditions for 409 and 422
+        if http_resp.status == 409:
+            raise ConflictException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 422:
+            raise UnprocessableEntityException(http_resp=http_resp, body=body, data=data)
+
+        if 500 <= http_resp.status <= 599:
+            raise ServiceException(http_resp=http_resp, body=body, data=data)
+        raise ApiException(http_resp=http_resp, body=body, data=data)
+
+    def __str__(self):
+        """Custom error messages for exception"""
+        error_message = "({0})\n" "Reason: {1}\n".format(self.status, self.reason)
+        if self.headers:
+            error_message += "HTTP response headers: {0}\n".format(self.headers)
+
+        if self.data or self.body:
+            error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+        return error_message
+
+
+class BadRequestException(ApiException):
+    pass
+
+
+class NotFoundException(ApiException):
+    pass
+
+
+class UnauthorizedException(ApiException):
+    pass
+
+
+class ForbiddenException(ApiException):
+    pass
+
+
+class ServiceException(ApiException):
+    pass
+
+
+class ConflictException(ApiException):
+    """Exception for HTTP 409 Conflict."""
+
+    pass
+
+
+class UnprocessableEntityException(ApiException):
+    """Exception for HTTP 422 Unprocessable Entity."""
+
+    pass
+
+
+def render_path(path_to_item):
+    """Returns a string representation of a path"""
+    result = ""
+    for pth in path_to_item:
+        if isinstance(pth, int):
+            result += "[{0}]".format(pth)
+        else:
+            result += "['{0}']".format(pth)
+    return result

src/stackit/vpn/models/__init__.py

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+# import models into model package
+from stackit.vpn.models.api_error import APIError
+from stackit.vpn.models.api_error_detail import APIErrorDetail
+from stackit.vpn.models.api_error_response import APIErrorResponse
+from stackit.vpn.models.bgp_gateway_config import BGPGatewayConfig
+from stackit.vpn.models.bgp_status import BGPStatus
+from stackit.vpn.models.bgp_status_peers import BGPStatusPeers
+from stackit.vpn.models.bgp_status_routes import BGPStatusRoutes
+from stackit.vpn.models.bgp_tunnel_config import BGPTunnelConfig
+from stackit.vpn.models.connection_list import ConnectionList
+from stackit.vpn.models.connection_response import ConnectionResponse
+from stackit.vpn.models.connection_status_response import ConnectionStatusResponse
+from stackit.vpn.models.create_gateway_connection_payload import (
+    CreateGatewayConnectionPayload,
+)
+from stackit.vpn.models.create_vpn_gateway_payload import CreateVPNGatewayPayload
+from stackit.vpn.models.create_vpn_gateway_payload_availability_zones import (
+    CreateVPNGatewayPayloadAvailabilityZones,
+)
+from stackit.vpn.models.gateway import Gateway
+from stackit.vpn.models.gateway_list import GatewayList
+from stackit.vpn.models.gateway_response import GatewayResponse
+from stackit.vpn.models.gateway_status import GatewayStatus
+from stackit.vpn.models.gateway_status_response import GatewayStatusResponse
+from stackit.vpn.models.peering_config import PeeringConfig
+from stackit.vpn.models.phase import Phase
+from stackit.vpn.models.phase1_status import Phase1Status
+from stackit.vpn.models.phase2_status import Phase2Status
+from stackit.vpn.models.plan import Plan
+from stackit.vpn.models.plan_list import PlanList
+from stackit.vpn.models.quota import Quota
+from stackit.vpn.models.quota_list import QuotaList
+from stackit.vpn.models.quota_list_response import QuotaListResponse
+from stackit.vpn.models.region import Region
+from stackit.vpn.models.routing_type import RoutingType
+from stackit.vpn.models.tunnel_configuration import TunnelConfiguration
+from stackit.vpn.models.tunnel_configuration_phase1 import TunnelConfigurationPhase1
+from stackit.vpn.models.tunnel_configuration_phase2 import TunnelConfigurationPhase2
+from stackit.vpn.models.tunnel_status import TunnelStatus
+from stackit.vpn.models.update_gateway_connection_payload import (
+    UpdateGatewayConnectionPayload,
+)
+from stackit.vpn.models.update_vpn_gateway_payload import UpdateVPNGatewayPayload
+from stackit.vpn.models.vpn_tunnels import VPNTunnels

src/stackit/vpn/models/api_error.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing_extensions import Self
+
+from stackit.vpn.models.api_error_detail import APIErrorDetail
+
+
+class APIError(BaseModel):
+    """
+    APIError
+    """  # noqa: E501
+
+    code: StrictInt = Field(description="The HTTP status code.")
+    details: Optional[List[APIErrorDetail]] = Field(default=None, description="Can contain more details on the error.")
+    message: StrictStr = Field(description="A message describing the error.")
+    status: StrictStr = Field(description="The HTTP status code text.")
+    __properties: ClassVar[List[str]] = ["code", "details", "message", "status"]
+
+    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 APIError 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 details (list)
+        _items = []
+        if self.details:
+            for _item_details in self.details:
+                if _item_details:
+                    _items.append(_item_details.to_dict())
+            _dict["details"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of APIError from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "code": obj.get("code"),
+                "details": (
+                    [APIErrorDetail.from_dict(_item) for _item in obj["details"]]
+                    if obj.get("details") is not None
+                    else None
+                ),
+                "message": obj.get("message"),
+                "status": obj.get("status"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/api_error_detail.py

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Self
+
+
+class APIErrorDetail(BaseModel):
+    """
+    APIErrorDetail
+    """  # noqa: E501
+
+    domain: StrictStr = Field(description="The domain of the error source.")
+    metadata: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Metadata contains more information. For bad requests this would be field information.",
+    )
+    reason: StrictStr = Field(description="The reason why the error occurs.")
+    __properties: ClassVar[List[str]] = ["domain", "metadata", "reason"]
+
+    @field_validator("reason")
+    def reason_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["INVALID_FIELD", "INVALID_PATH_PARAMETER"]):
+            raise ValueError("must be one of enum values ('INVALID_FIELD', 'INVALID_PATH_PARAMETER')")
+        return value
+
+    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 APIErrorDetail 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 APIErrorDetail from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "domain": obj.get("domain") if obj.get("domain") is not None else "vpn.access.stackit.cloud",
+                "metadata": obj.get("metadata"),
+                "reason": obj.get("reason"),
+            }
+        )
+        return _obj