catalystwan 0.40.1.dev6__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

catalystwan/{session.py → core/session.py}

@@ -1,24 +1,14 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
 from __future__ import annotations
 
 import logging
 from enum import Enum
-from functools import cached_property
-from pathlib import Path
 from time import monotonic, sleep
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+from typing import Callable, List, Optional, Union
 from urllib.parse import urljoin, urlparse, urlunparse
 
-from packaging.version import Version  # type: ignore
-from requests import PreparedRequest, Request, Response, Session, get, head
-from requests.exceptions import ConnectionError, HTTPError, RequestException
-
-from catalystwan import USER_AGENT
-from catalystwan.apigw_auth import ApiGwAuth, ApiGwLogin, LoginMode
-from catalystwan.endpoints import APIEndpointClient
-from catalystwan.endpoints.client import AboutInfo, ServerInfo
-from catalystwan.exceptions import (
+from catalystwan.abc import SessionInterface, SessionType
+from catalystwan.core.apigw_auth import ApiGwAuth, ApiGwLogin, LoginMode
+from catalystwan.core.exceptions import (
     DefaultPasswordError,
     ManagerHTTPError,
     ManagerReadyTimeout,
@@ -26,18 +16,14 @@ from catalystwan.exceptions import (
     SessionNotCreatedError,
     TenantSubdomainNotFound,
 )
-from catalystwan.models.tenant import Tenant
-from catalystwan.request_limiter import RequestLimiter
-from catalystwan.response import ManagerResponse, response_history_debug
-from catalystwan.utils.session_type import SessionType
-from catalystwan.version import NullVersion, parse_api_version
-from catalystwan.vmanage_auth import create_vmanage_auth, vManageAuth
-
-JSON = Union[Dict[str, "JSON"], List["JSON"], str, int, float, bool, None]
-
-if TYPE_CHECKING:
-    from catalystwan.api.api_container import APIContainer
-    from catalystwan.endpoints.endpoints_container import APIEndpointContainter
+from catalystwan.core.metadata import USER_AGENT
+from catalystwan.core.request_limiter import RequestLimiter
+from catalystwan.core.response import ManagerResponse, response_history_debug
+from catalystwan.core.version import NullVersion, parse_api_version
+from catalystwan.core.vmanage_auth import create_vmanage_auth, vManageAuth
+from packaging.version import Version  # type: ignore
+from requests import PreparedRequest, Request, Response, Session, get, head
+from requests.exceptions import ConnectionError, HTTPError, RequestException
 
 
 class UserMode(str, Enum):
@@ -70,14 +56,31 @@ def determine_session_type(
     tenancy_mode: Optional[str], user_mode: Optional[str], view_mode: Optional[str]
 ) -> SessionType:
     modes_map = {
-        (TenancyMode.SINGLE_TENANT, UserMode.TENANT, ViewMode.TENANT): SessionType.SINGLE_TENANT,
-        (TenancyMode.MULTI_TENANT, UserMode.PROVIDER, ViewMode.PROVIDER): SessionType.PROVIDER,
-        (TenancyMode.MULTI_TENANT, UserMode.PROVIDER, ViewMode.TENANT): SessionType.PROVIDER_AS_TENANT,
-        (TenancyMode.MULTI_TENANT, UserMode.TENANT, ViewMode.TENANT): SessionType.TENANT,
+        (
+            TenancyMode.SINGLE_TENANT,
+            UserMode.TENANT,
+            ViewMode.TENANT,
+        ): SessionType.SINGLE_TENANT,
+        (
+            TenancyMode.MULTI_TENANT,
+            UserMode.PROVIDER,
+            ViewMode.PROVIDER,
+        ): SessionType.PROVIDER,
+        (
+            TenancyMode.MULTI_TENANT,
+            UserMode.PROVIDER,
+            ViewMode.TENANT,
+        ): SessionType.PROVIDER_AS_TENANT,
+        (
+            TenancyMode.MULTI_TENANT,
+            UserMode.TENANT,
+            ViewMode.TENANT,
+        ): SessionType.TENANT,
     }
     try:
         return modes_map.get(
-            (TenancyMode(tenancy_mode), UserMode(user_mode), ViewMode(view_mode)), SessionType.NOT_DEFINED
+            (TenancyMode(tenancy_mode), UserMode(user_mode), ViewMode(view_mode)),
+            SessionType.NOT_DEFINED,
         )
     except ValueError:
         return SessionType.NOT_DEFINED
@@ -145,7 +148,12 @@ def create_apigw_session(
         ),
         logger=logger,
     )
-    session_ = ManagerSession(base_url=create_base_url(url, port), auth=auth, subdomain=subdomain, logger=logger)
+    session_ = ManagerSession(
+        base_url=create_base_url(url, port),
+        auth=auth,
+        subdomain=subdomain,
+        logger=logger,
+    )
     session_.state = ManagerSessionState.LOGIN
     return session_
 
@@ -200,7 +208,7 @@ class ManagerResponseAdapter(Session):
         return ManagerResponse(super().delete(url, *args, **kwargs))
 
 
-class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
+class ManagerSession(ManagerResponseAdapter, SessionInterface):
     """Base class for API sessions for vManage client.
 
     Defines methods and handles session connectivity available for provider, provider as tenant, and tenant.
@@ -257,20 +265,6 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
         self._last_request: Optional[PreparedRequest] = None
         self._limiter: RequestLimiter = request_limiter or RequestLimiter()
 
-    @cached_property
-    def api(self) -> APIContainer:
-        from catalystwan.api.api_container import APIContainer
-
-        self._api = APIContainer(self)
-        return self._api
-
-    @cached_property
-    def endpoints(self) -> APIEndpointContainter:
-        from catalystwan.endpoints.endpoints_container import APIEndpointContainter
-
-        self._endpoints = APIEndpointContainter(self)
-        return self._endpoints
-
     @property
     def state(self) -> ManagerSessionState:
         return self._state
@@ -328,20 +322,21 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
         self._auth.clear(self._last_request)
         self.auth = self._auth
 
-    def _fetch_server_info(self) -> ServerInfo:
+    def _fetch_server_info(self) -> dict:
         try:
-            server_info = self.server()
+            server_info = self.get("dataservice/client/server").json()["data"]
         except DefaultPasswordError:
-            server_info = ServerInfo.model_construct(**{})
+            server_info = {}
 
         return server_info
 
-    def _finalize_login(self, server_info: ServerInfo) -> None:
-        self.server_name = server_info.server
+    def _finalize_login(self, server_info: dict) -> None:
+        self.server_name = server_info.get("server")
+        self.platform_version = server_info.get("platformVersion")  # type: ignore[assignment]
 
-        tenancy_mode = server_info.tenancy_mode
-        user_mode = server_info.user_mode
-        view_mode = server_info.view_mode
+        tenancy_mode = server_info.get("tenancyMode")
+        user_mode = server_info.get("userMode")
+        view_mode = server_info.get("viewMode")
 
         self._session_type = determine_session_type(tenancy_mode, user_mode, view_mode)
 
@@ -427,7 +422,9 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
     def request(self, method, url, *args, **kwargs) -> ManagerResponse:
         full_url = self.get_full_url(url)
         _kwargs = dict(kwargs)
-        if self.request_timeout is not None:  # do not modify user provided kwargs unless property is set
+        if (
+            self.request_timeout is not None
+        ):  # do not modify user provided kwargs unless property is set
             _kwargs.update(timeout=self.request_timeout)
         try:
             with self._limiter:
@@ -437,11 +434,15 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
                 self.state = ManagerSessionState.WAIT_SERVER_READY_AFTER_RESTART
         except RequestException as exception:
             self.logger.debug(self.response_trace(exception.response, exception.request))
-            if self.state == ManagerSessionState.RESTART_IMMINENT and isinstance(exception, ConnectionError):
+            if self.state == ManagerSessionState.RESTART_IMMINENT and isinstance(
+                exception, ConnectionError
+            ):
                 self.state = ManagerSessionState.WAIT_SERVER_READY_AFTER_RESTART
                 return self.request(method, url, *args, **_kwargs)
             self.logger.debug(exception)
-            raise ManagerRequestException(*exception.args, request=exception.request, response=exception.response)
+            raise ManagerRequestException(
+                *exception.args, request=exception.request, response=exception.response
+            )
 
         self._last_request = response.request
         if response.jsessionid_expired and self.state in [
@@ -452,7 +453,9 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
             if self.state == ManagerSessionState.LOGIN_IN_PROGRESS:
                 self.state = ManagerSessionState.AUTH_SYNC
             else:
-                self.logger.warning("Logging to session. Reason: expired JSESSIONID detected in response headers")
+                self.logger.warning(
+                    "Logging to session. Reason: expired JSESSIONID detected in response headers"
+                )
                 self.state = ManagerSessionState.LOGIN
             return self.request(method, url, *args, **_kwargs)
 
@@ -464,7 +467,9 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
             if self.state == ManagerSessionState.LOGIN_IN_PROGRESS:
                 self.state = ManagerSessionState.AUTH_SYNC
             else:
-                self.logger.warning("Logging to API GW session. Reason: unauthorized detected in response headers")
+                self.logger.warning(
+                    "Logging to API GW session. Reason: unauthorized detected in response headers"
+                )
                 self.state = ManagerSessionState.LOGIN
             return self.request(method, url, *args, **_kwargs)
 
@@ -476,67 +481,45 @@ class ManagerSession(ManagerResponseAdapter, APIEndpointClient):
         except HTTPError as error:
             self.logger.debug(error)
             error_info = response.get_error_info()
-            raise ManagerHTTPError(*error.args, error_info=error_info, request=error.request, response=error.response)
+            raise ManagerHTTPError(
+                *error.args,
+                error_info=error_info,
+                request=error.request,
+                response=error.response,
+            )
         return response
 
     def get_full_url(self, url_path: str) -> str:
         """Returns base API url plus given url path."""
         return urljoin(self.base_url, url_path)
 
-    def about(self) -> AboutInfo:
-        return self.endpoints.client.about()
-
-    def server(self) -> ServerInfo:
-        server_info = self.endpoints.client.server()
-        self.platform_version = server_info.platform_version
-        return server_info
-
-    def get_data(self, url: str) -> Any:
-        return self.get_json(url)["data"]
-
-    def get_json(self, url: str) -> Any:
-        response = self.get(url)
-        return response.json()
-
-    def get_file(self, url: str, filename: Path) -> Response:
-        """Get a file using session get.
-
-        Args:
-            url: dataservice api.
-            filename: Filename to write download file to.
-
-        Returns:
-            http response.
-
-        Example usage:
-            response = self.session.get_file(url, filename)
-
-        """
-        with self.get(url) as response:
-            with open(filename, "wb") as file:
-                file.write(response.content)
-        return response
-
     def get_tenant_id(self) -> str:
         """Gets tenant UUID for its subdomain.
 
         Returns:
             Tenant UUID.
         """
-        tenants = self.get("dataservice/tenant").dataseq(Tenant)
-        tenant = tenants.filter(subdomain=self.subdomain).single_or_default()
-
-        if not tenant or not tenant.tenant_id:
+        tenants: List[dict] = list(
+            filter(
+                lambda x: x["subdomain"] == self.subdomain,
+                self.get("dataservice/tenant").json(),
+            )
+        )
+        try:
+            tenant = tenants[0]
+        except IndexError:
+            tenant = None
+        if tenant is None or tenant.get("tenantId") is None:
             raise TenantSubdomainNotFound(f"Tenant ID for sub-domain: {self.subdomain} not found")
 
-        return tenant.tenant_id
+        return tenant["tenantId"]
 
     def logout(self) -> None:
         if self._added_to_auth:
             self._auth.decrease_session_count()
         self._auth.logout(self)
 
-    def close(self) -> None:
+    def close(self, *args) -> None:
         """Closes the ManagerSession.
 
         This method is overrided from requests.Session.

catalystwan/core/types.py

@@ -0,0 +1,33 @@
+from dataclasses import Field
+from typing import Any, ClassVar, Dict, Literal, Protocol, Union
+
+from typing_extensions import Annotated
+
+
+def is_variable(s: Any):
+    return isinstance(s, str) and s.startswith(r"{{") and s.endswith(r"}}")
+
+
+def to_variable(s: str):
+    if is_variable(s):
+        return s
+    return r"{{" + s + r"}}"
+
+
+Variable = Annotated[str, is_variable, to_variable]
+
+
+class AliasPath(list): ...
+
+
+def get_alias(alias: Union[str, AliasPath, None]):
+    if isinstance(alias, AliasPath):
+        return alias[-1]
+    return alias
+
+
+MODEL_TYPES = Literal["base", "feature_template", "parcel"]
+
+
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[Dict[str, Field]]

catalystwan/{version.py → core/version.py}

@@ -1,9 +1,7 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
 import re
 
-from packaging._structures import NegativeInfinity  # type: ignore
-from packaging.version import InvalidVersion, Version  # type: ignore
+from packaging._structures import NegativeInfinity
+from packaging.version import InvalidVersion, Version
 
 
 class NullVersion(Version):
@@ -16,7 +14,7 @@ class NullVersion(Version):
     def __init__(self):
         """Initialize a NullVersion object."""
         super().__init__("0")
-        self._key = (
+        self._key = (  # type: ignore
             NegativeInfinity,
             NegativeInfinity,
             NegativeInfinity,

catalystwan/{vmanage_auth.py → core/vmanage_auth.py}

@@ -1,23 +1,20 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
 import logging
 from http.cookies import SimpleCookie
 from threading import RLock
 from typing import Optional
 from urllib.parse import urlparse
 
+from catalystwan.abc import SessionInterface
+from catalystwan.core.abstractions import AuthProtocol
+from catalystwan.core.exceptions import CatalystwanException, TenantSubdomainNotFound
+from catalystwan.core.metadata import USER_AGENT
+from catalystwan.core.response import auth_response_debug
+from catalystwan.core.version import NullVersion
 from packaging.version import Version  # type: ignore
 from requests import PreparedRequest, Response, get, post
 from requests.auth import AuthBase
 from requests.cookies import RequestsCookieJar, merge_cookies
 
-from catalystwan import USER_AGENT
-from catalystwan.abstractions import APIEndpointClient, AuthProtocol
-from catalystwan.exceptions import CatalystwanException, TenantSubdomainNotFound
-from catalystwan.models.tenant import Tenant
-from catalystwan.response import ManagerResponse, auth_response_debug
-from catalystwan.version import NullVersion
-
 
 class UnauthorizedAccessError(CatalystwanException):
     """Exception raised for wrong username/password or when user not authorized to access vManage.
@@ -71,7 +68,13 @@ class vManageAuth(AuthBase, AuthProtocol):
     2. Get a cross-site request forgery prevention token, which is required for most POST operations.
     """
 
-    def __init__(self, username: str, password: str, logger: Optional[logging.Logger] = None, verify: bool = False):
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        logger: Optional[logging.Logger] = None,
+        verify: bool = False,
+    ):
         self.username = username
         self.password = password
         self.xsrftoken: Optional[str] = None
@@ -108,8 +111,13 @@ class vManageAuth(AuthBase, AuthProtocol):
             "j_password": self.password,
         }
         url = self._base_url + "/j_security_check"
-        headers = {"Content-Type": "application/x-www-form-urlencoded", "User-Agent": USER_AGENT}
-        response: Response = post(url=url, headers=headers, data=security_payload, verify=self.verify)
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": USER_AGENT,
+        }
+        response: Response = post(
+            url=url, headers=headers, data=security_payload, verify=self.verify
+        )
         self.sync_cookies(response.cookies)
         self.logger.debug(auth_response_debug(response, str(self)))
         if response.text != "" or not isinstance(self.jsessionid, str) or self.jsessionid == "":
@@ -132,11 +140,13 @@ class vManageAuth(AuthBase, AuthProtocol):
         return response.text
 
     def authenticate(self, request: PreparedRequest):
-        self._base_url = f"{str(urlparse(request.url).scheme)}://{str(urlparse(request.url).netloc)}"  # noqa: E231
+        self._base_url = (
+            f"{str(urlparse(request.url).scheme)}://{str(urlparse(request.url).netloc)}"  # noqa: E231
+        )
         self.get_jsessionid()
         self.xsrftoken = self.get_xsrftoken()
 
-    def logout(self, client: APIEndpointClient) -> None:
+    def logout(self, client: SessionInterface) -> None:
         with self.lock:
             if self.session_count > 1:
                 # Other sessions still use the auth, unregister and return
@@ -151,11 +161,17 @@ class vManageAuth(AuthBase, AuthProtocol):
                 headers = {"x-xsrf-token": self.xsrftoken, "User-Agent": USER_AGENT}
                 if version >= Version("20.12"):
                     response = post(
-                        f"{self._base_url}/logout", headers=headers, cookies=self.cookies, verify=self.verify
+                        f"{self._base_url}/logout",
+                        headers=headers,
+                        cookies=self.cookies,
+                        verify=self.verify,
                     )
                 else:
                     response = get(
-                        f"{self._base_url}/logout", headers=headers, cookies=self.cookies, verify=self.verify
+                        f"{self._base_url}/logout",
+                        headers=headers,
+                        cookies=self.cookies,
+                        verify=self.verify,
                     )
                 self.logger.debug(auth_response_debug(response, str(self)))
                 if response.status_code != 200:
@@ -225,7 +241,11 @@ class vSessionAuth(vManageAuth):
 
     def get_tenantid(self) -> str:
         url = self._base_url + "/dataservice/tenant"
-        headers = {"Content-Type": "application/json", "User-Agent": USER_AGENT, "x-xsrf-token": self.xsrftoken}
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT,
+            "x-xsrf-token": self.xsrftoken,
+        }
         response: Response = get(
             url=url,
             cookies=self.cookies,
@@ -234,15 +254,20 @@ class vSessionAuth(vManageAuth):
         )
         self.sync_cookies(response.cookies)
         self.logger.debug(auth_response_debug(response, str(self)))
-        tenants = ManagerResponse(response).dataseq(Tenant)
-        tenant = tenants.filter(subdomain=self.subdomain).single_or_default()
+        tenants = response.json()
+        tenant = next((t for t in tenants if t.get("subDomain") == self.subdomain), None)
+
         if not tenant or not tenant.tenant_id:
             raise TenantSubdomainNotFound(f"Tenant ID for sub-domain: {self.subdomain} not found")
-        return tenant.tenant_id
+        return tenant["tenantId"]
 
     def get_vsessionid(self, tenantid: str) -> str:
         url = self._base_url + f"/dataservice/tenant/{tenantid}/vsessionid"
-        headers = {"Content-Type": "application/json", "User-Agent": USER_AGENT, "x-xsrf-token": self.xsrftoken}
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT,
+            "x-xsrf-token": self.xsrftoken,
+        }
         response: Response = post(
             url=url,
             cookies=self.cookies,