pyixapi 0.2.7__tar.gz → 0.3.0__tar.gz

{pyixapi-0.2.7 → pyixapi-0.3.0}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.4
 Name: pyixapi
-Version: 0.2.7
+Version: 0.3.0
 Summary: Python API client library for IX-API
-License-Expression: Apache-2.0
-License-File: LICENSE
 Author: Guillaume Mazoyer
-Author-email: oss@mazoyer.eu
-Requires-Python: >=3.10
+Author-email: Guillaume Mazoyer <oss@mazoyer.eu>
+License-Expression: Apache-2.0
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -14,11 +12,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Provides-Extra: dev
-Requires-Dist: PyJWT (>=2.4.0,<2.11)
-Requires-Dist: pytest ; extra == "dev"
-Requires-Dist: requests (>=2.32.4,<3.0)
-Requires-Dist: ruff (>=0.14,<0.15) ; extra == "dev"
+Requires-Dist: pyjwt>=2.4.0,<2.14
+Requires-Dist: requests>=2.32.4,<3.0
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # pyixapi
@@ -79,4 +75,3 @@ DXDB:PAS:00008
 ```
 
 Write queries are not implemented yet.
-

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/api.py

@@ -1,4 +1,5 @@
 import warnings
+from typing import Any
 
 import requests
 
@@ -11,6 +12,7 @@ from pyixapi.models import (
     IP,
     MAC,
     Account,
+    AvailabilityZone,
     Connection,
     Contact,
     Demarc,
@@ -29,9 +31,10 @@ from pyixapi.models import (
     ProductOffering,
     Role,
     RoleAssignment,
+    RoutingFunction,
 )
 
-__version__ = "0.2.7"
+__version__ = "0.3.0"
 
 
 class API(object):
@@ -44,14 +47,14 @@ class API(object):
 
     def __init__(
         self,
-        url,
-        key,
-        secret,
-        access_token="",
-        refresh_token="",
-        user_agent=f"pyixapi/{__version__}",
-        proxies=None,
-    ):
+        url: str,
+        key: str,
+        secret: str,
+        access_token: str = "",
+        refresh_token: str = "",
+        user_agent: str = f"pyixapi/{__version__}",
+        proxies: dict[str, str] | None = None,
+    ) -> None:
         self.url = url.rstrip("/")
         self.key = key
         self.secret = secret
@@ -60,11 +63,11 @@ class API(object):
         self.http_session = requests.Session()
         self.user_agent = user_agent
         self.proxies = proxies
+        self._version: int | None = None
 
         self.auth = Endpoint(self, "auth")
         self.connections = Endpoint(self, "connections", model=Connection)
         self.contacts = Endpoint(self, "contacts", model=Contact)
-        self.demarcs = Endpoint(self, "demarcs", model=Demarc)
         self.devices = Endpoint(self, "devices", model=Device)
         self.facilities = Endpoint(self, "facilities", model=Facility)
         self.ips = Endpoint(self, "ips", model=IP)
@@ -75,6 +78,7 @@ class API(object):
         self.network_services = Endpoint(self, "network-services", model=NetworkService)
         self.pops = Endpoint(self, "pops", model=PoP)
         # Version 2+
+        self.availability_zones = Endpoint(self, "availability-zones", model=AvailabilityZone)
         self.member_joining_rules = Endpoint(self, "member-joining-rules", model=MemberJoiningRule)
         self.metro_areas = Endpoint(self, "metro-areas", model=MetroArea)
         self.metro_area_networks = Endpoint(self, "metro-area-networks", model=MetroAreaNetwork)
@@ -82,12 +86,19 @@ class API(object):
         self.port_reservations = Endpoint(self, "port-reservations", model=PortReservation)
         self.roles = Endpoint(self, "roles", model=Role)
         self.role_assignments = Endpoint(self, "role-assignments", model=RoleAssignment)
+        self.routing_functions = Endpoint(self, "routing-functions", model=RoutingFunction)
 
     @property
     def version(self) -> int:
         """
         Get the API version of IX-API.
+
+        The version is resolved once on first access and cached for the lifetime
+        of the API instance, as it does not change between requests.
         """
+        if self._version is not None:
+            return self._version
+
         version = Request(
             base=self.url,
             token=self.access_token,
@@ -103,21 +114,43 @@ class API(object):
                 stacklevel=2,
             )
 
+        self._version = version
         return version
 
     @property
-    def accounts(self):
+    def accounts(self) -> Endpoint:
         return Endpoint(self, "customers" if self.version == 1 else "accounts", model=Account)
 
     @property
-    def product_offerings(self):
+    def demarcs(self) -> Endpoint:
+        if self.version != 1:
+            raise AttributeError("demarcs endpoint is only available in IX-API v1")
+        return Endpoint(self, "demarcs", model=Demarc)
+
+    @property
+    def product_offerings(self) -> Endpoint:
         return Endpoint(
             self,
             "products" if self.version == 1 else "product-offerings",
             model=ProductOffering,
         )
 
-    def authenticate(self):
+    def account(self) -> Account:
+        """
+        Get the authenticated user's own account.
+
+        Available in IX-API 2 or newer.
+        """
+        r = Request(
+            base=cat(self.url, "account"),
+            token=self.access_token,
+            http_session=self.http_session,
+            user_agent=self.user_agent,
+            proxies=self.proxies,
+        )
+        return Account(r._make_call(), self, self.accounts)
+
+    def authenticate(self) -> Record | None:
         """
         Authenticate and generate a pair of tokens.
 
@@ -147,13 +180,16 @@ class API(object):
 
         return Record(r, self, self.auth)
 
-    def refresh_authentication(self):
+    def refresh_authentication(self) -> Record:
         """
         Prolong authentication by refreshing the tokens pair.
         """
+        if not self.refresh_token:
+            raise ValueError("No refresh token available to refresh authentication")
+
         r = Request(
             cat(self.url, "auth", "refresh"),
-            token=self.refresh_token.encoded,
+            token=self.refresh_token,
             http_session=self.http_session,
             user_agent=self.user_agent,
             proxies=self.proxies,
@@ -164,7 +200,21 @@ class API(object):
 
         return Record(r, self, self.auth)
 
-    def health(self):
+    def extensions(self) -> list[dict[str, Any]]:
+        """
+        Get the list of extensions supported by the IX-API implementation.
+
+        Available in IX-API 2 or newer.
+        """
+        return Request(
+            base=cat(self.url, "extensions"),
+            token=self.access_token,
+            http_session=self.http_session,
+            user_agent=self.user_agent,
+            proxies=self.proxies,
+        )._make_call()
+
+    def health(self) -> dict[str, Any]:
         """
         Get the health information from IX-API.
 
@@ -180,3 +230,17 @@ class API(object):
             user_agent=self.user_agent,
             proxies=self.proxies,
         ).get_health()
+
+    def implementation(self) -> dict[str, Any]:
+        """
+        Get implementation details of the IX-API server.
+
+        Available in IX-API 2 or newer.
+        """
+        return Request(
+            base=cat(self.url, "implementation"),
+            token=self.access_token,
+            http_session=self.http_session,
+            user_agent=self.user_agent,
+            proxies=self.proxies,
+        )._make_call()

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/endpoint.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from pyixapi.core.query import Request, RequestError
 from pyixapi.core.response import Record, RecordSet
 from pyixapi.core.util import cat
 
+if TYPE_CHECKING:
+    from pyixapi.core.api import API
+
 
 class Endpoint(object):
     """
@@ -11,16 +18,16 @@ class Endpoint(object):
     object.
     """
 
-    def __init__(self, api, name, model=None):
-        self.return_obj = model if model else Record
+    def __init__(self, api: API, name: str, model: type[Record] | None = None) -> None:
+        self.return_obj: type[Record] = model if model else Record
         self.api = api
         self.url = cat(api.url, name)
         self.name = name
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.url
 
-    def all(self):
+    def all(self) -> RecordSet:
         """
         Return all objects from an endpoint.
         """
@@ -33,7 +40,7 @@ class Endpoint(object):
         )
         return RecordSet(self, r)
 
-    def filter(self, *args, **kwargs):
+    def filter(self, *args: Any, **kwargs: Any) -> RecordSet:
         """
         Query the list of a given endpoint. Also take named arguments that match the
         usable filters on a given endpoint.
@@ -48,7 +55,7 @@ class Endpoint(object):
         )
         return RecordSet(self, r)
 
-    def get(self, *args, **kwargs):
+    def get(self, *args: Any, **kwargs: Any) -> Record | None:
         """
         Return a single object from an endpoint.
         """
@@ -89,7 +96,7 @@ class Endpoint(object):
             else:
                 raise e
 
-    def create(self, *args, **kwargs):
+    def create(self, *args: Any, **kwargs: Any) -> Record:
         """
         Creates an object on an endpoint.
 

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/query.py

@@ -1,5 +1,9 @@
 import json
+from typing import Any, Generator
 
+import requests
+
+from pyixapi.core.token import Token
 from pyixapi.core.util import cat
 
 
@@ -10,7 +14,7 @@ class RequestError(Exception):
     return is JSON we decode and add it to the message.
     """
 
-    def __init__(self, r):
+    def __init__(self, r: requests.Response) -> None:
         if r.status_code == 404:
             self.message = f"The requested url: {r.url} could not be found."
         elif r.status_code == 401:
@@ -27,7 +31,7 @@ class RequestError(Exception):
         self.req = r
         self.error = r.text
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.message
 
 
@@ -38,13 +42,13 @@ class ContentError(Exception):
     those cases.
     """
 
-    def __init__(self, req):
+    def __init__(self, req: requests.Response) -> None:
         super(ContentError, self).__init__(req)
 
         self.req = req
         self.error = "The server returned invalid (non-JSON) data. Maybe not an IX-API server?"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.error
 
 
@@ -55,22 +59,20 @@ class Request(object):
     Responsible for building the URL and making the HTTP(S) requests to the API.
 
     :param base: (str) Base URL passed in api() instantiation.
-    :param filters: (dict, optional) contains key/value pairs that correlate to the
-        filters a given endpoint accepts.
-        In (e.g. /api/v1/devices?name='test') 'name': 'test' would be in the filters
-        dict.
+    :param filters: (dict, optional) key/value pairs matching the filters an
+        endpoint accepts, e.g. {"name": "test"} for /devices?name=test.
     """
 
     def __init__(
         self,
-        base,
-        http_session,
-        filters=None,
-        key=None,
-        token=None,
-        user_agent=None,
-        proxies=None,
-    ):
+        base: str,
+        http_session: requests.Session,
+        filters: dict[str, Any] | None = None,
+        key: str | None = None,
+        token: Token | None = None,
+        user_agent: str | None = None,
+        proxies: dict[str, str] | None = None,
+    ) -> None:
         self.base = base
         self.filters = filters or None
         self.key = key
@@ -80,18 +82,7 @@ class Request(object):
         self.user_agent = user_agent
         self.proxies = proxies
 
-    def get_openapi(self):
-        """
-        Get the OpenAPI Spec.
-        """
-        headers = {"Content-Type": "application/json;"}
-        req = self.http_session.get(cat(self.base, "docs/?format=openapi"), headers=headers)
-        if req.ok:
-            return req.json()
-        else:
-            raise RequestError(req)
-
-    def get_version(self):
+    def get_version(self) -> int:
         """
         Get the API version of IX-API.
 
@@ -105,32 +96,38 @@ class Request(object):
         except RequestError:
             return 1
 
-    def get_health(self):
+    def get_health(self) -> dict[str, Any]:
         """
         Get the health from /api/health endpoint in IX-API.
         """
-        headers = {"Content-Type": "application/json;"}
+        headers: dict[str, str] = {"Content-Type": "application/json;"}
         if self.token:
-            headers["Authorization"] = f"Bearer {self.token}"
+            headers["Authorization"] = f"Bearer {self.token.encoded}"
         r = self.http_session.get(cat(self.base, "health"), headers=headers)
         if r.ok:
             return r.json()
         else:
             raise RequestError(r)
 
-    def _make_call(self, verb="get", url_override=None, add_params=None, data=None):
-        if verb in ("post", "put") or verb == "delete" and data:
-            headers = {"Content-Type": "application/json;"}
+    def _make_call(
+        self,
+        verb: str = "get",
+        url_override: str | None = None,
+        add_params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> Any:
+        if verb in ("post", "put") or (verb == "delete" and data):
+            headers: dict[str, str] = {"Content-Type": "application/json;"}
         else:
             headers = {"accept": "application/json;"}
 
         if self.token:
-            headers["Authorization"] = f"Bearer {self.token}"
+            headers["Authorization"] = f"Bearer {self.token.encoded}"
 
         if self.user_agent:
             headers["User-Agent"] = self.user_agent
 
-        params = {}
+        params: dict[str, Any] = {}
         if not url_override:
             if self.filters:
                 params.update(self.filters)
@@ -158,7 +155,7 @@ class Request(object):
         else:
             raise RequestError(r)
 
-    def get(self, add_params=None):
+    def get(self, add_params: dict[str, Any] | None = None) -> Generator[dict[str, Any], None, None]:
         """
         Make a GET request to IX-API.
 
@@ -174,10 +171,10 @@ class Request(object):
             for i in req:
                 yield i
         else:
-            self.count = len(req)
+            self.count = 1
             yield req
 
-    def put(self, data):
+    def put(self, data: dict[str, Any]) -> dict[str, Any]:
         """
         Make a PUT request to IX-API.
 
@@ -189,7 +186,7 @@ class Request(object):
         """
         return self._make_call(verb="put", data=data)
 
-    def post(self, data):
+    def post(self, data: dict[str, Any]) -> dict[str, Any]:
         """
         Make a POST request to IX-API.
 
@@ -201,7 +198,7 @@ class Request(object):
         """
         return self._make_call(verb="post", data=data)
 
-    def delete(self, data=None):
+    def delete(self, data: dict[str, Any] | None = None) -> bool:
         """
         Make a DELETE request to IX-API.
 
@@ -215,7 +212,7 @@ class Request(object):
         """
         return self._make_call(verb="delete", data=data)
 
-    def patch(self, data):
+    def patch(self, data: dict[str, Any]) -> dict[str, Any]:
         """
         Make a PATCH request to IX-API.
 
@@ -227,7 +224,7 @@ class Request(object):
         """
         return self._make_call(verb="patch", data=data)
 
-    def options(self):
+    def options(self) -> dict[str, Any]:
         """
         Make an OPTIONS request to IX-API.
 

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/response.py

@@ -1,8 +1,16 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Iterator
+
 from pyixapi.core.query import Request
-from pyixapi.core.util import Hashabledict
+from pyixapi.core.util import Hashabledict, cat
+
+if TYPE_CHECKING:
+    from pyixapi.core.api import API
+    from pyixapi.core.endpoint import Endpoint
 
 
-def get_return(lookup):
+def get_return(lookup: Any) -> Any:
     """
     Return simple representations for items passed to lookup.
 
@@ -52,21 +60,21 @@ class RecordSet(object):
     >>>
     """
 
-    def __init__(self, endpoint, request, **kwargs):
+    def __init__(self, endpoint: Endpoint, request: Request, **kwargs: Any) -> None:
         self.endpoint = endpoint
         self.request = request
         self.response = self.request.get()
-        self._response_cache = []
+        self._response_cache: list[dict[str, Any]] = []
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Record]:
         return self
 
-    def __next__(self):
+    def __next__(self) -> Record:
         if self._response_cache:
             return self.endpoint.return_obj(self._response_cache.pop(), self.endpoint.api, self.endpoint)
         return self.endpoint.return_obj(next(self.response), self.endpoint.api, self.endpoint)
 
-    def __len__(self):
+    def __len__(self) -> int:
         try:
             return self.request.count
         except AttributeError:
@@ -82,11 +90,11 @@ class Record(object):
     Create Python objects from IX-API responses.
 
     Nested dicts that represent other endpoints are also turned into
-    :py:class:`.Record` objects. All fields are then assigned to the object's
-    attributes. If a missing attribute is requested (e.g. requesting a field that's
-    only present on a full response on a :py:class:`.Record` made from a nested
-    response) then pyixapi will make a request for the full object and return the
-    requested value.
+    :py:class:`.Record` objects (when the corresponding model declares them as a
+    class attribute). All fields are then assigned to the object's attributes.
+
+    Only the fields present in the response are set as attributes; accessing a
+    field that was not returned raises :py:exc:`AttributeError`.
 
     :examples:
     Default representation of the object is usually its ID and/or name:
@@ -138,18 +146,17 @@ class Record(object):
     >>>
     """
 
-    url = None
+    url: str | None = None
 
-    def __init__(self, values, api, endpoint):
-        self._full_cache = []
-        self._init_cache = []
+    def __init__(self, values: dict[str, Any], api: API, endpoint: Endpoint) -> None:
+        self._init_cache: list[tuple[str, Any]] = []
         self.api = api
-        self.default_ret = Record
+        self.default_ret: type[Record] = Record
         self.endpoint = endpoint
         if values:
             self._parse_values(values)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[tuple[str, Any]]:
         for i in dict(self._init_cache):
             a = getattr(self, i)
             if isinstance(a, Record):
@@ -159,53 +166,46 @@ class Record(object):
             else:
                 yield i, a
 
-    def __getitem__(self, k):
+    def __getitem__(self, k: str) -> Any:
         return dict(self)[k]
 
-    def __str__(self):
+    def __str__(self) -> str:
         if hasattr(self, "id"):
             return self.id
         else:
             return str(self.endpoint)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return str(dict(self))
 
-    def __getstate__(self):
-        return self.__dict__
-
-    def __setstate__(self, d):
-        self.__dict__.update(d)
-
-    def __key__(self):
+    def __key__(self) -> tuple[str, ...] | tuple[str]:
         if hasattr(self, "id"):
             return (self.endpoint.name, self.id)
         else:
-            return self.endpoint.name
+            return (self.endpoint.name,)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.__key__())
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, Record):
             return self.__key__() == other.__key__()
         return NotImplemented
 
-    def _add_cache(self, item):
+    def _add_cache(self, item: tuple[str, Any]) -> None:
         key, value = item
         self._init_cache.append((key, get_return(value)))
 
-    def _parse_values(self, values):
+    def _parse_values(self, values: dict[str, Any]) -> None:
         """
         Parse values dict at init and sets object attributes with the values within.
         """
 
-        def list_parser(key_name, list_item):
+        def list_parser(key_name: str, list_item: Any) -> Any:
             if isinstance(list_item, dict):
                 lookup = getattr(self.__class__, key_name, None)
                 if not isinstance(lookup, list):
-                    # This is *list_parser*, so if the custom model field is not
-                    # a list (or is not defined), just return the default model
+                    # Field not declared as a list model: use the default Record.
                     return self.default_ret(list_item, self.api, self.endpoint)
                 else:
                     model = lookup[0]
@@ -226,7 +226,7 @@ class Record(object):
                 self._add_cache((k, v))
             setattr(self, k, v)
 
-    def serialize(self, nested=False, init=False):
+    def serialize(self, nested: bool = False, init: bool = False) -> Any:
         """
         Pull all the attributes in an object and create a dict that can be turned into
         the JSON that IX-API is expecting.
@@ -240,7 +240,7 @@ class Record(object):
         if init:
             init_vals = dict(self._init_cache)
 
-        r = {}
+        r: dict[str, Any] = {}
         for i in dict(self):
             current_val = getattr(self, i) if not init else init_vals.get(i)
             if isinstance(current_val, Record):
@@ -250,19 +250,21 @@ class Record(object):
             r[i] = current_val
         return r
 
-    def _diff(self):
-        def fmt_dict(k, v):
+    def _diff(self) -> set[str]:
+        def make_hashable(v: Any) -> Any:
+            # Hashable, structure-preserving form for set comparison. Lists become
+            # tuples, not a joined string (which would collide).
             if isinstance(v, dict):
-                return k, Hashabledict(v)
+                return Hashabledict({k: make_hashable(val) for k, val in v.items()})
             if isinstance(v, list):
-                return k, ",".join(map(str, v))
-            return k, v
+                return tuple(make_hashable(i) for i in v)
+            return v
 
-        current = Hashabledict({fmt_dict(k, v) for k, v in self.serialize().items()})
-        init = Hashabledict({fmt_dict(k, v) for k, v in self.serialize(init=True).items()})
-        return set([i[0] for i in set(current.items()) ^ set(init.items())])
+        current = {k: make_hashable(v) for k, v in self.serialize().items()}
+        init = {k: make_hashable(v) for k, v in self.serialize(init=True).items()}
+        return {key for key, _ in set(current.items()) ^ set(init.items())}
 
-    def updates(self):
+    def updates(self) -> dict[str, Any]:
         """
         Compile changes for an existing object into a dict.
 
@@ -276,7 +278,16 @@ class Record(object):
                 return {i: serialized[i] for i in diff}
         return {}
 
-    def save(self):
+    def _make_request(self, sub_path: str) -> Request:
+        return Request(
+            base=cat(self.endpoint.url, self.id, sub_path),
+            token=self.api.access_token,
+            http_session=self.api.http_session,
+            user_agent=self.api.user_agent,
+            proxies=self.api.proxies,
+        )
+
+    def save(self) -> bool:
         """
         Save changes to an existing object.
 
@@ -290,14 +301,19 @@ class Record(object):
                 base=self.endpoint.url,
                 token=self.api.access_token,
                 http_session=self.api.http_session,
-                user_agent=self.user_agent,
+                user_agent=self.api.user_agent,
                 proxies=self.api.proxies,
             )
-            if r.patch(updates):
+            result = r.patch(updates)
+            if result:
+                # Refresh the record from the server response
+                if isinstance(result, dict):
+                    self._init_cache = []
+                    self._parse_values(result)
                 return True
         return False
 
-    def update(self, data):
+    def update(self, data: dict[str, Any]) -> bool:
         """
         Update an object with a dictionary.
 
@@ -309,7 +325,7 @@ class Record(object):
             setattr(self, k, v)
         return self.save()
 
-    def delete(self):
+    def delete(self) -> bool:
         """
         Delete an existing object.
         """
@@ -318,7 +334,7 @@ class Record(object):
             base=self.endpoint.url,
             token=self.api.access_token,
             http_session=self.api.http_session,
-            user_agent=self.user_agent,
+            user_agent=self.api.user_agent,
             proxies=self.api.proxies,
         )
-        return True if r.delete() else False
+        return r.delete()

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/token.py

@@ -29,9 +29,6 @@ class Token:
         self.encoded: str = token  # Cache signed token data
         self.expires_at: datetime = expires_at
 
-    def __str__(self) -> str:
-        return self.encoded
-
     def __repr__(self) -> str:
         return f"<Token ttl={self.ttl}s>"
 
@@ -49,7 +46,7 @@ class Token:
         TTL is the number of seconds, from now, before the token expires.
         """
         seconds = (self.expires_at - datetime.now(timezone.utc)).total_seconds()
-        return max(0, seconds)
+        return max(0, int(seconds))
 
     @property
     def is_expired(self) -> bool:

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/core/util.py

@@ -1,8 +1,8 @@
 from typing import Any
 
 
-class Hashabledict(dict):
-    def __hash__(self):
+class Hashabledict(dict):  # type: ignore[type-arg]
+    def __hash__(self) -> int:
         return hash(frozenset(self))
 
 
@@ -15,16 +15,16 @@ def cat(*args: Any, separator: str = "/", trailing: str = "") -> str:
 
     If an item cannot be parsed as a string, an AttributeError will be raised.
 
-    >>> concatenate("a", "b", "c")
-    'a/b/c/'
-    >>> concatenate("a", "b", "/c/", separator="")
+    >>> cat("a", "/b/", "c/")
     'a/b/c'
-    >>> concatenate("a", "/b/", 1)
-    'a/b/1/'
-    >>> concatenate("a", "b", "c", separator="_", trailing="_")
-    'a_b_c_'
+    >>> cat("a", 1, "b")
+    'a/1/b'
+    >>> cat("a", "b", "c", separator="_")
+    'a_b_c'
+    >>> cat("a", "b", "c", trailing="/")
+    'a/b/c/'
     """
-    s = separator.join([str(i).lstrip(separator).rstrip(separator) for i in args])
+    s = separator.join([str(i).strip(separator) for i in args if str(i)])
     if trailing:
         s += trailing
     return s

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyixapi/models.py

@@ -1,4 +1,5 @@
 import ipaddress
+from typing import Any
 
 from pyixapi.core.response import Record
 
@@ -12,7 +13,7 @@ class Account(Record):
     It is also referenced as "customer" in IX-API v1.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.id}: {self.name}"
 
 
@@ -21,16 +22,31 @@ class Connection(Record):
     A Connection is a group of physical ports collected together into a LAG.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.id}: {self.name}"
 
+    def cancellation_policy(self) -> dict[str, Any]:
+        return self._make_request("cancellation-policy")._make_call()
+
+    def get_loa(self) -> dict[str, Any]:
+        return self._make_request("loa")._make_call()
+
+    def upload_loa(self, data: dict[str, Any]) -> dict[str, Any]:
+        return self._make_request("loa")._make_call(verb="post", data=data)
+
+    def statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("statistics")._make_call(add_params=kwargs or None)
+
+    def statistics_timeseries(self, aggregate: str, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request(f"statistics/{aggregate}/timeseries")._make_call(add_params=kwargs or None)
+
 
 class Contact(Record):
     """
     A Contact is a role undertaking a specific responsibility within an account.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         r = []
 
         legal_company_name = getattr(self, "legal_company_name", None)
@@ -51,7 +67,7 @@ class Demarc(Record):
     eg a physical port / socket, generally with a specified bandwidth.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
 
@@ -61,7 +77,7 @@ class Device(Record):
     specified facility and inside a PoP.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -71,7 +87,7 @@ class Facility(Record):
     defined set of PoPs can be accessed.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -81,18 +97,18 @@ class IP(Record):
     """
 
     @property
-    def cidr(self):
+    def cidr(self) -> ipaddress.IPv4Interface | ipaddress.IPv6Interface:
         return ipaddress.ip_interface(f"{self.address}/{self.prefix_length}")
 
     @property
-    def ip(self):
+    def ip(self) -> ipaddress.IPv4Address | ipaddress.IPv6Address:
         return self.cidr.ip
 
     @property
-    def network(self):
+    def network(self) -> ipaddress.IPv4Network | ipaddress.IPv6Network:
         return self.cidr.network
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.cidr)
 
 
@@ -101,7 +117,7 @@ class MAC(Record):
     A MAC is a MAC address with a given validity period.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.address.lower()
 
 
@@ -110,7 +126,7 @@ class NetworkFeatureConfig(Record):
     A NetworkFeatureConfig is a customer's configuration to use a NetworkFeature.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
 
@@ -120,7 +136,7 @@ class NetworkFeature(Record):
     NetworkService.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
 
@@ -130,9 +146,24 @@ class NetworkServiceConfig(Record):
     the configuration of a (subset of a) connection for that customer's traffic.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
+    def cancellation_policy(self) -> dict[str, Any]:
+        return self._make_request("cancellation-policy")._make_call()
+
+    def peer_statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("peer-statistics")._make_call(add_params=kwargs or None)
+
+    def peer_statistics_timeseries(self, aggregate: str, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request(f"peer-statistics/{aggregate}/timeseries")._make_call(add_params=kwargs or None)
+
+    def statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("statistics")._make_call(add_params=kwargs or None)
+
+    def statistics_timeseries(self, aggregate: str, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request(f"statistics/{aggregate}/timeseries")._make_call(add_params=kwargs or None)
+
 
 class NetworkService(Record):
     """
@@ -140,9 +171,30 @@ class NetworkService(Record):
     depending on the type of product.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
+    def cancellation_policy(self) -> dict[str, Any]:
+        return self._make_request("cancellation-policy")._make_call()
+
+    def change_request(self) -> dict[str, Any]:
+        return self._make_request("change-request")._make_call()
+
+    def create_change_request(self, data: dict[str, Any]) -> dict[str, Any]:
+        return self._make_request("change-request")._make_call(verb="post", data=data)
+
+    def delete_change_request(self) -> bool:
+        return self._make_request("change-request")._make_call(verb="delete")
+
+    def rtt_statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("rtt-statistics")._make_call(add_params=kwargs or None)
+
+    def statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("statistics")._make_call(add_params=kwargs or None)
+
+    def statistics_timeseries(self, aggregate: str, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request(f"statistics/{aggregate}/timeseries")._make_call(add_params=kwargs or None)
+
 
 class PoP(Record):
     """
@@ -150,7 +202,7 @@ class PoP(Record):
     infrastructure and has defined reachability of other facilities.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -161,13 +213,22 @@ class ProductOffering(Record):
     It is also referenced as "product" in IX-API v1.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
 # Version 2 and up
 
 
+class AvailabilityZone(Record):
+    """
+    An AvailabilityZone describes the physical location or zone of a resource.
+    """
+
+    def __str__(self) -> str:
+        return self.name
+
+
 class MemberJoiningRule(Record):
     """
     A MemberJoiningRule defines a rule to allow or deny access for an Account to a
@@ -177,7 +238,7 @@ class MemberJoiningRule(Record):
     listed in an allow rule.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
 
@@ -186,7 +247,7 @@ class MetroArea(Record):
     A MetroArea exists if a MetroAreaNetwork or Facility is present in it.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.display_name
 
 
@@ -199,7 +260,7 @@ class MetroAreaNetwork(Record):
     list of IDs.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -209,9 +270,15 @@ class Port(Record):
     associated with a device and pop, has a speed and a media_type.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
+    def statistics(self, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request("statistics")._make_call(add_params=kwargs or None)
+
+    def statistics_timeseries(self, aggregate: str, **kwargs: Any) -> dict[str, Any]:
+        return self._make_request(f"statistics/{aggregate}/timeseries")._make_call(add_params=kwargs or None)
+
 
 class PortReservation(Record):
     """
@@ -223,16 +290,38 @@ class PortReservation(Record):
     Please note that individual cancellation policies might apply.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id
 
+    def cancellation_policy(self) -> dict[str, Any]:
+        return self._make_request("cancellation-policy")._make_call()
+
+    def get_loa(self) -> dict[str, Any]:
+        return self._make_request("loa")._make_call()
+
+    def upload_loa(self, data: dict[str, Any]) -> dict[str, Any]:
+        return self._make_request("loa")._make_call(verb="post", data=data)
+
+
+class RoutingFunction(Record):
+    """
+    A RoutingFunction is a function that provides routing capabilities within a
+    network service.
+    """
+
+    def __str__(self) -> str:
+        return self.id
+
+    def cancellation_policy(self) -> dict[str, Any]:
+        return self._make_request("cancellation-policy")._make_call()
+
 
 class Role(Record):
     """
     A Role enables a Contact to act for a specific purpose.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
@@ -241,5 +330,5 @@ class RoleAssignment(Record):
     A Contact can be assigned to many Roles.
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.id

{pyixapi-0.2.7 → pyixapi-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyixapi"
-version = "0.2.7"
+version = "0.3.0"
 description = "Python API client library for IX-API"
 authors = [{ name = "Guillaume Mazoyer", email = "oss@mazoyer.eu" }]
 readme = "README.md"
@@ -15,14 +15,10 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
-dependencies = ["PyJWT>=2.4.0,<2.11", "requests>=2.32.4,<3.0"]
+dependencies = ["PyJWT>=2.4.0,<2.14", "requests>=2.32.4,<3.0"]
 
-[project.optional-dependencies]
-dev = ["pytest", "ruff>=0.14,<0.15"]
-
-[tool.poetry]
-requires-poetry = ">=2.0"
-packages = [{ include = "pyixapi" }]
+[dependency-groups]
+dev = ["pytest", "pytest-cov", "ruff", "ty"]
 
 [tool.ruff]
 line-length = 120
@@ -57,6 +53,24 @@ known-first-party = ["pyixapi"]
 [tool.ruff.lint.mccabe]
 max-complexity = 31
 
+[tool.ty.rules]
+unresolved-attribute = "ignore"
+invalid-return-type = "ignore"
+unresolved-import = "ignore"
+
+[tool.pytest.ini_options]
+addopts = "--cov=pyixapi --cov-branch --cov-report=term-missing --cov-report=xml"
+
+[tool.coverage.run]
+source = ["pyixapi"]
+omit = ["pyixapi/__main__.py"]
+
+[tool.coverage.report]
+exclude_lines = ["if TYPE_CHECKING:"]
+
 [build-system]
-requires = ["poetry-core>=2.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["uv_build>=0.9.21,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = "."

pyixapi-0.2.7/LICENSE

@@ -1,178 +0,0 @@
-
-                             Apache License
-                       Version 2.0, January 2004
-                    http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-  "License" shall mean the terms and conditions for use, reproduction,
-  and distribution as defined by Sections 1 through 9 of this document.
-
-  "Licensor" shall mean the copyright owner or entity authorized by
-  the copyright owner that is granting the License.
-
-  "Legal Entity" shall mean the union of the acting entity and all
-  other entities that control, are controlled by, or are under common
-  control with that entity. For the purposes of this definition,
-  "control" means (i) the power, direct or indirect, to cause the
-  direction or management of such entity, whether by contract or
-  otherwise, or (ii) ownership of fifty percent (50%) or more of the
-  outstanding shares, or (iii) beneficial ownership of such entity.
-
-  "You" (or "Your") shall mean an individual or Legal Entity
-  exercising permissions granted by this License.
-
-  "Source" form shall mean the preferred form for making modifications,
-  including but not limited to software source code, documentation
-  source, and configuration files.
-
-  "Object" form shall mean any form resulting from mechanical
-  transformation or translation of a Source form, including but
-  not limited to compiled object code, generated documentation,
-  and conversions to other media types.
-
-  "Work" shall mean the work of authorship, whether in Source or
-  Object form, made available under the License, as indicated by a
-  copyright notice that is included in or attached to the work
-  (an example is provided in the Appendix below).
-
-  "Derivative Works" shall mean any work, whether in Source or Object
-  form, that is based on (or derived from) the Work and for which the
-  editorial revisions, annotations, elaborations, or other modifications
-  represent, as a whole, an original work of authorship. For the purposes
-  of this License, Derivative Works shall not include works that remain
-  separable from, or merely link (or bind by name) to the interfaces of,
-  the Work and Derivative Works thereof.
-
-  "Contribution" shall mean any work of authorship, including
-  the original version of the Work and any modifications or additions
-  to that Work or Derivative Works thereof, that is intentionally
-  submitted to Licensor for inclusion in the Work by the copyright owner
-  or by an individual or Legal Entity authorized to submit on behalf of
-  the copyright owner. For the purposes of this definition, "submitted"
-  means any form of electronic, verbal, or written communication sent
-  to the Licensor or its representatives, including but not limited to
-  communication on electronic mailing lists, source code control systems,
-  and issue tracking systems that are managed by, or on behalf of, the
-  Licensor for the purpose of discussing and improving the Work, but
-  excluding communication that is conspicuously marked or otherwise
-  designated in writing by the copyright owner as "Not a Contribution."
-
-  "Contributor" shall mean Licensor and any individual or Legal Entity
-  on behalf of whom a Contribution has been received by Licensor and
-  subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  copyright license to reproduce, prepare Derivative Works of,
-  publicly display, publicly perform, sublicense, and distribute the
-  Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  (except as stated in this section) patent license to make, have made,
-  use, offer to sell, sell, import, and otherwise transfer the Work,
-  where such license applies only to those patent claims licensable
-  by such Contributor that are necessarily infringed by their
-  Contribution(s) alone or by combination of their Contribution(s)
-  with the Work to which such Contribution(s) was submitted. If You
-  institute patent litigation against any entity (including a
-  cross-claim or counterclaim in a lawsuit) alleging that the Work
-  or a Contribution incorporated within the Work constitutes direct
-  or contributory patent infringement, then any patent licenses
-  granted to You under this License for that Work shall terminate
-  as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-  Work or Derivative Works thereof in any medium, with or without
-  modifications, and in Source or Object form, provided that You
-  meet the following conditions:
-
-  (a) You must give any other recipients of the Work or
-      Derivative Works a copy of this License; and
-
-  (b) You must cause any modified files to carry prominent notices
-      stating that You changed the files; and
-
-  (c) You must retain, in the Source form of any Derivative Works
-      that You distribute, all copyright, patent, trademark, and
-      attribution notices from the Source form of the Work,
-      excluding those notices that do not pertain to any part of
-      the Derivative Works; and
-
-  (d) If the Work includes a "NOTICE" text file as part of its
-      distribution, then any Derivative Works that You distribute must
-      include a readable copy of the attribution notices contained
-      within such NOTICE file, excluding those notices that do not
-      pertain to any part of the Derivative Works, in at least one
-      of the following places: within a NOTICE text file distributed
-      as part of the Derivative Works; within the Source form or
-      documentation, if provided along with the Derivative Works; or,
-      within a display generated by the Derivative Works, if and
-      wherever such third-party notices normally appear. The contents
-      of the NOTICE file are for informational purposes only and
-      do not modify the License. You may add Your own attribution
-      notices within Derivative Works that You distribute, alongside
-      or as an addendum to the NOTICE text from the Work, provided
-      that such additional attribution notices cannot be construed
-      as modifying the License.
-
-  You may add Your own copyright statement to Your modifications and
-  may provide additional or different license terms and conditions
-  for use, reproduction, or distribution of Your modifications, or
-  for any such Derivative Works as a whole, provided Your use,
-  reproduction, and distribution of the Work otherwise complies with
-  the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-  any Contribution intentionally submitted for inclusion in the Work
-  by You to the Licensor shall be under the terms and conditions of
-  this License, without any additional terms or conditions.
-  Notwithstanding the above, nothing herein shall supersede or modify
-  the terms of any separate license agreement you may have executed
-  with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-  names, trademarks, service marks, or product names of the Licensor,
-  except as required for reasonable and customary use in describing the
-  origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-  agreed to in writing, Licensor provides the Work (and each
-  Contributor provides its Contributions) on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-  implied, including, without limitation, any warranties or conditions
-  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-  PARTICULAR PURPOSE. You are solely responsible for determining the
-  appropriateness of using or redistributing the Work and assume any
-  risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-  whether in tort (including negligence), contract, or otherwise,
-  unless required by applicable law (such as deliberate and grossly
-  negligent acts) or agreed to in writing, shall any Contributor be
-  liable to You for damages, including any direct, indirect, special,
-  incidental, or consequential damages of any character arising as a
-  result of this License or out of the use or inability to use the
-  Work (including but not limited to damages for loss of goodwill,
-  work stoppage, computer failure or malfunction, or any and all
-  other commercial damages or losses), even if such Contributor
-  has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-  the Work or Derivative Works thereof, You may choose to offer,
-  and charge a fee for, acceptance of support, warranty, indemnity,
-  or other liability obligations and/or rights consistent with this
-  License. However, in accepting such obligations, You may act only
-  on Your own behalf and on Your sole responsibility, not on behalf
-  of any other Contributor, and only if You agree to indemnify,
-  defend, and hold each Contributor harmless for any liability
-  incurred by, or claims asserted against, such Contributor by reason
-  of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-Copyright 2017 DigitalOcean