allphins-sdk 1.0.4__tar.gz

allphins_sdk-1.0.4/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: allphins-sdk
+Version: 1.0.4
+Summary: 
+Author: Florent
+Author-email: florent@allphins.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pandas (>=2.1.4,<3.0.0)
+Requires-Dist: pyarrow (>=15.0.0,<16.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Description-Content-Type: text/markdown
+
+# allphins-sdk
+Allphins SKD repository
+
+## How to contribute
+
+1) Install pre-commit hook
+```bash
+> pre-commit install
+```
+
+2) Convention followed
+
+- [PEP8](https://www.python.org/dev/peps/pep-0008/) -> 120 characters per line
+
+- [Google Python Style Docstring]
+
+## Requirements
+* [Poetry](https://python-poetry.org/docs/#installation)
+* [Docker](https://docs.docker.com/get-docker/)
+* [Docker-compose](https://docs.docker.com/compose/install/)
+
+## How to set up poetry environment
+To set up your development environment using poetry you have to install all the dependencies using:
+
+```
+poetry install --with dev
+```
+
+You can also run the documentation on a local environment:
+
+```
+poetry run mkdocs serve
+```
+The documentation will be running on your localhost port 8000
+
+Finally, you can run the unit test using the following command:  
+
+```
+poetry run coverage run --source=./allphins tests && poetry run coverage report --fail-under=80
+```
+
+## Mock allphins-api
+You can mock the allphins-api by using the following command:
+```
+docker-compose up -d
+```
+All calls to localhost:8080 will be redirected to the mock server.
+You can update the mock server by updating the files in the stubs/allphins-api folder.
+
+This is required before runing local tests.

allphins_sdk-1.0.4/README.md

@@ -0,0 +1,50 @@
+# allphins-sdk
+Allphins SKD repository
+
+## How to contribute
+
+1) Install pre-commit hook
+```bash
+> pre-commit install
+```
+
+2) Convention followed
+
+- [PEP8](https://www.python.org/dev/peps/pep-0008/) -> 120 characters per line
+
+- [Google Python Style Docstring]
+
+## Requirements
+* [Poetry](https://python-poetry.org/docs/#installation)
+* [Docker](https://docs.docker.com/get-docker/)
+* [Docker-compose](https://docs.docker.com/compose/install/)
+
+## How to set up poetry environment
+To set up your development environment using poetry you have to install all the dependencies using:
+
+```
+poetry install --with dev
+```
+
+You can also run the documentation on a local environment:
+
+```
+poetry run mkdocs serve
+```
+The documentation will be running on your localhost port 8000
+
+Finally, you can run the unit test using the following command:  
+
+```
+poetry run coverage run --source=./allphins tests && poetry run coverage report --fail-under=80
+```
+
+## Mock allphins-api
+You can mock the allphins-api by using the following command:
+```
+docker-compose up -d
+```
+All calls to localhost:8080 will be redirected to the mock server.
+You can update the mock server by updating the files in the stubs/allphins-api folder.
+
+This is required before runing local tests.

allphins_sdk-1.0.4/allphins/__init__.py

@@ -0,0 +1,14 @@
+"""___  _       _________ _______  _______  _______  _______
+(  ____ \( \      \__   __/(  ____ )(  ____ )(  ____ \(  ____ )
+| (    \/| (         ) (   | (    )|| (    )|| (    \/| (    )|
+| (__    | |         | |   | (____)|| (____)|| (__    | (____)|
+|  __)   | |         | |   |  _____)|  _____)|  __)   |     __)
+| (      | |         | |   | (      | (      | (      | (\ (
+| )      | (____/\___) (___| )      | )      | (____/\| ) \ \__
+|/       (_______/\_______/|/       |/       (_______/|/   \__/
+
+"""
+
+from allphins.interface import get_policies  # noqa: F401
+from allphins.interface import get_portfolios  # noqa: F401
+from allphins.interface import get_risks  # noqa: F401

allphins_sdk-1.0.4/allphins/client/__init__.py

@@ -0,0 +1,5 @@
+"""Get resources from Allphins API."""
+
+from allphins.client.client import Client
+
+__all__ = ["Client"]

allphins_sdk-1.0.4/allphins/client/auth.py

@@ -0,0 +1,101 @@
+"""Authentication class for the Allphins API."""
+import os
+from typing import Optional
+
+import requests
+from requests import HTTPError
+
+from allphins.const import ACCESS_TOKEN_URL
+from allphins.const import REFRESH_TOKEN_URL
+from allphins.status import HTTP_401_UNAUTHORIZED
+
+
+class Auth:
+    """Authentication class for the Allphins API.
+
+    This class manages the access and refresh tokens.
+    The credentials are provided in the constructor or via environment variables.
+
+    Attributes:
+        _access_token: The access token.
+        _refresh_token: The refresh token.
+    """
+
+    REQUEST_TIMEOUT = 3
+
+    def __init__(self, username: Optional[str] = None, password: Optional[str] = None):
+        """Initialize the authentication object.
+
+        Credentials are extracted from method parameters in priority and then from environment variable.
+
+        Args:
+            username: (Optional str) The username to use for authentication.
+            password: (Optional str) The password to use for authentication.
+
+        Raises:
+            ValueError: If the username or password is not provided.
+        """
+        self._access_token: Optional[str] = None
+        self._refresh_token: Optional[str] = None
+
+        username = os.environ.get('ALLPHINS_APIKEY') if username is None else username
+        password = os.environ.get('ALLPHINS_PASSKEY') if password is None else password
+        error_message = '{credential} must be provided. You can setup the {env_var} environment variable.'
+
+        if not username:
+            raise ValueError(error_message.format(credential='Username', env_var='ALLPHINS_USER'))
+
+        if not password:
+            raise ValueError(error_message.format(credential='Password', env_var='ALLPHINS_PASSWORD'))
+
+        self.username = username
+        self.password = password
+
+        self._get_tokens()
+
+    def _get_tokens(self):
+        """Get the access and refresh token.
+
+        This method is called in the constructor to get the tokens.
+
+        Raises:
+            ValueError: If the username or password is invalid.
+            HTTPError: If the request fails.
+        """
+        json = {
+            'username': self.username,
+            'password': self.password,
+        }
+        response = requests.post(ACCESS_TOKEN_URL, json=json, timeout=self.REQUEST_TIMEOUT)
+        try:
+            response.raise_for_status()
+        except HTTPError as e:
+            if response.status_code == HTTP_401_UNAUTHORIZED:
+                raise ValueError('Invalid username or password')
+            else:
+                raise e
+        response_json = response.json()
+        self._access_token = response_json['access']
+        self._refresh_token = response_json['refresh']
+
+    def refresh_access_token(self):
+        """Refresh the access token.
+
+        Raises:
+             HTTPError: If the request fails.
+        """
+        json = {
+            'refresh': self._refresh_token,
+        }
+        response = requests.post(REFRESH_TOKEN_URL, json=json, timeout=self.REQUEST_TIMEOUT)
+        response.raise_for_status()
+        self._access_token = response.json()['access']
+
+    def get_authentication_header(self) -> dict:
+        """Get the authentication header to be added in any requests.
+
+        Returns:
+            The authentication header.
+            Example: {'Authorization': 'Bearer xxxx'}.
+        """
+        return {'Authorization': f'Bearer {self._access_token}', 'User-Agent': 'Allphins SDK/1.0.4'}

allphins_sdk-1.0.4/allphins/client/client.py

@@ -0,0 +1,176 @@
+"""Base class for client used to interact with Allphins API."""
+from typing import Any
+from typing import Optional
+
+import requests
+from requests import HTTPError
+from requests import Response
+from tqdm import tqdm
+
+from allphins.client.auth import Auth
+from allphins.singleton import Singleton
+from allphins.status import HTTP_403_FORBIDDEN
+
+
+class Client(metaclass=Singleton):
+    """Client to bundle configuration needed for API requests.
+
+    The Client is a singleton. It is instantiated once and then reused, it's to avoid requesting different tokens
+    for every type of objects using a :class:`Client`
+
+
+    Attributes:
+        auth: The authentication object to use for authentication.
+    """
+
+    REQUEST_TIMEOUT = 180  # seconds
+
+    def __init__(self, auth: Optional[Auth] = None):
+        """Initialize the client.
+
+        If no value is passed in for auth, a :class:`Auth` instance will be created with credentials read
+        via environment variables.
+
+        Args:
+            auth: (Optional) The authentication object to use for authentication.
+        """
+        if auth is None:
+            auth = Auth()
+        self.auth = auth
+
+    def call_api(
+        self,
+        url: str,
+        method: str,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+        page_size: Optional[int] = None,
+    ) -> Any:
+        """Call the API.
+
+        Access token is automatically manged by the Auth class.
+        If the token is expired, it will be refreshed and the call will be retried.
+
+        Args:
+            url: (str) The url to call.
+            method: (str) The method to use for the request (GET, POST, PUT, DELETE...).
+            json: (Optional dict) The json to send with the request.
+            headers: (Optional dict) The headers to send with the request.
+            page_size: (Optional int) Specify the page size for the pagination. None means no pagination.
+
+        Returns:
+            Any: The response from the API.
+
+        Raises:
+             HTTPError: If the request fails.
+        """
+        response = self._perform_call(url, method, json, headers, page_size)
+        try:
+            response.raise_for_status()
+        except HTTPError as e:
+            if response.status_code == HTTP_403_FORBIDDEN:
+                self.auth.refresh_access_token()
+                response = self._perform_call(url, method, json, headers, page_size)
+                response.raise_for_status()
+            else:
+                raise e
+        return response.json()
+
+    def call_api_with_pagination(
+        self,
+        url: str,
+        method: str,
+        page_size: int,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> list:
+        """Call the API with pagination.
+
+        Automatically iterate through the pages to get all the results.
+        Display progress bar based on the number of results.
+        Access token is automatically manged by the Auth class.
+        If the token is expired, it will be refreshed and the call will be retried.
+
+        Args:
+            url: (str) The url to call.
+            method: (str) The method to use for the request (GET, POST, PUT, DELETE...).
+            page_size: (int) Specify the page size for the pagination.
+            json: (Optional dict) The json to send with the request.
+            headers: (Optional dict) The headers to send with the request.
+
+        Returns:
+            Any: The response from the API.
+
+        Raises:
+             HTTPError: If the request fails.
+        """
+        result: list = list()
+
+        call = self.call_api(url, method, json, headers, page_size)
+        with tqdm(total=call['count']) as pbar:
+            while call['next']:
+                result.extend(call['results'])
+                pbar.update(len(call['results']))
+                pbar.refresh()
+                call = self.call_api(url, method, json, headers, page_size)
+
+            result.extend(call['results'])
+            pbar.update(len(call['results']))
+
+        return result
+
+    def _perform_call(
+        self,
+        url: str,
+        method: str,
+        json: Optional[dict],
+        headers: Optional[dict],
+        page_size: Optional[int],
+    ) -> Response:
+        """Perform the API call.
+
+        Args:
+            url: (str) The url to call.
+            method: (str) The method to use for the request (GET, POST, PUT, DELETE...).
+            json: (Optional dict) The json to send with the request.
+            headers: (Optional dict) The headers to send with the request.
+            page_size: (Optional int) Specify the page size for the pagination. None means no pagination.
+
+
+        Returns:
+            Response: The Response object from requests.
+
+        Raises:
+             HTTPError: If the request fails.
+        """
+        if headers is None:
+            headers = {}
+
+        auth_header = self.auth.get_authentication_header()
+        headers = {**headers, **auth_header}
+        url = Client._set_page_size(url, page_size)
+
+        response = requests.request(method, url, headers=headers, json=json, timeout=self.REQUEST_TIMEOUT)
+        return response
+
+    @staticmethod
+    def _set_page_size(url: str, page_size: Optional[int]) -> str:
+        """Append the pagination to the url.
+
+        By default, the API paginates the results. To get all the results, we need to set the pageSize to None.
+
+        Args:
+            url: The url to append the pagination to.
+
+        Returns:
+            str: The url with the pagination appended.
+        """
+        if 'pageSize' in url:
+            return url
+
+        if '?' in url:
+            url += '&'
+        else:
+            url += '?'
+        url += f'pageSize={page_size}'
+        return url

allphins_sdk-1.0.4/allphins/client/result.py

@@ -0,0 +1,56 @@
+"""Wrap all the result of the client."""
+from typing import Protocol
+
+import pandas as pd
+
+
+class Result(Protocol):
+    """Wrap the result of the client."""
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Return the result as a pandas DataFrame."""
+        ...
+
+    def to_json(self) -> dict | list:
+        """Return the result as a dict."""
+        ...
+
+
+class DictResult:
+    """Wrap dict result."""
+
+    def __init__(self, data: dict | list) -> None:
+        """Generate the result class.
+
+        Args:
+            data (dict): data from the api
+        """
+        self._data = data
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Return the result as a pandas DataFrame."""
+        return pd.DataFrame(self._data)
+
+    def to_json(self) -> dict | list:
+        """Return the result as a dict."""
+        return self._data
+
+
+class PandasResult:
+    """Wrap Pandas result."""
+
+    def __init__(self, data: pd.DataFrame) -> None:
+        """Generate the result class.
+
+        Args:
+            data (dict): data from the api
+        """
+        self._data = data
+
+    def to_pandas(self) -> pd.DataFrame:
+        """Return the result as a pandas DataFrame."""
+        return self._data
+
+    def to_json(self) -> dict | list:
+        """Return the result as a dict."""
+        return self._data.to_dict('records')

allphins_sdk-1.0.4/allphins/const.py

@@ -0,0 +1,11 @@
+"""Constants for the project."""
+import os
+
+ALLPHINS_API_URL = f"{os.environ.get('ALLPHINS_URL', 'https://app.allphins.com')}/api/v1"
+ACCESS_TOKEN_URL = f'{ALLPHINS_API_URL}/token/'
+REFRESH_TOKEN_URL = f'{ALLPHINS_API_URL}/token/refresh/'
+
+GET = 'GET'
+POST = 'POST'
+
+ISO_8601 = '%Y-%m-%d'

allphins_sdk-1.0.4/allphins/interface.py

@@ -0,0 +1,115 @@
+"""This module provides methods to interact with the allphins API."""
+import logging
+import uuid
+from typing import Optional
+
+from pandas import DataFrame
+
+from allphins.models import Policy
+from allphins.models import Portfolio
+from allphins.models import Risk
+from allphins.models.policy import PolicyStatuses
+from allphins.utils import validate_uuid4
+
+logger = logging.getLogger(__name__)
+
+
+def get_portfolios() -> DataFrame:
+    """Get all the portfolios.
+
+    Returns:
+        dataframe of the portfolios' representation.
+    """
+    return Portfolio.all().to_pandas()
+
+
+def get_policies(
+    portfolio_id: Optional[uuid.UUID] = None,
+    status: Optional[str] = 'written',
+    filter_rule: Optional[str] = 'today',
+) -> DataFrame:
+    """Get the policies, using filtering parameters.
+
+    Values for status:
+        * quote
+        * written
+        * expired
+        * declined
+        * not_taken_up
+        * work_in_progress
+        * deleted
+
+    Values for filter_rule:
+        * today (policies live today)
+        * previous_1_1 (policies live on the previous 1st of January)
+
+    Args:
+        portfolio_id (Optional[uuid.UUID]): UUID of the portfolio.
+        status (Optional[str]): Status of the policy
+        filter_rule (Optional[str]): Filter rule to apply
+
+    Returns:
+        dataframe of the policies' representation.
+    """
+    filters: dict = {}
+
+    if portfolio_id:
+        if not validate_uuid4(portfolio_id):
+            raise ValueError(f'{portfolio_id} is not a valid UUID.')
+        filters['portfolio_id'] = portfolio_id
+
+    if filter_rule:
+        if filter_rule not in ['today', 'previous_1_1']:
+            raise ValueError(f'{filter_rule} is not a valid filter rule.')
+        filters['filter_rule'] = filter_rule
+
+    if status:
+        try:
+            PolicyStatuses(status)
+        except ValueError:
+            raise ValueError(f'{status} is not a valid status.')
+        filters['status'] = status
+
+    return Policy.filtered_policies(filters).to_pandas()
+
+
+def get_risks(
+    portfolio_id: Optional[uuid.UUID] = None,
+    datasource_id: Optional[uuid.UUID] = None,
+    scenario_id: Optional[int] = None,
+) -> DataFrame:
+    """Get the risks, using filtering parameters.
+
+    At least one of the parameters must be provided.
+
+    Fetching the risks from the API could take a while, depending on the amount of data to retrieve.
+
+    Args:
+        portfolio_id (Optional[uuid.UUID]): UUID of the portfolio.
+        datasource_id (Optional[uuid.UUID]): UUID of the datasource_id.
+        scenario_id (Optional[int]): id of the scenario_id.
+
+    Returns:
+        dataframe of the risks' representation.
+    """
+    if not any([portfolio_id, datasource_id, scenario_id]):
+        raise ValueError('At least one of the parameters must be provided.')
+
+    filters: dict = {}
+
+    if portfolio_id:
+        if not validate_uuid4(portfolio_id):
+            raise ValueError(f'{portfolio_id} is not a valid UUID.')
+        filters['portfolios'] = portfolio_id
+
+    if datasource_id:
+        if not validate_uuid4(datasource_id):
+            raise ValueError(f'{datasource_id} is not a valid UUID.')
+        filters['datasource_id'] = datasource_id
+
+    if scenario_id:
+        filters['scenario_id'] = scenario_id
+
+    logger.info('Fetching risks from the API, this could take a while...')
+
+    return Risk.filtered_risk(filters).to_pandas()

allphins_sdk-1.0.4/allphins/models/__init__.py

@@ -0,0 +1,10 @@
+"""Get resources from Allphins API."""
+
+from allphins.models.datasource import Datasource
+from allphins.models.policy import Policy
+from allphins.models.portfolio import Portfolio
+from allphins.models.risk import Risk
+from allphins.models.scenario import Scenario
+from allphins.models.scenario_list import ScenarioList
+
+__all__ = ["Datasource", "Policy", "Portfolio", "Risk", "Scenario", "ScenarioList"]

allphins_sdk-1.0.4/allphins/models/base.py

@@ -0,0 +1,75 @@
+"""Base class for models."""
+from typing import Any
+from typing import TypeVar
+
+from allphins.client.client import Client
+from allphins.client.result import DictResult
+from allphins.client.result import Result
+from allphins.const import GET
+
+T = TypeVar('T', bound='BaseModel')
+
+
+class BaseModel:
+    """This class is the base for all the models.
+
+    It serves as a wrapper for all operations (API calls) that can be done on the model.
+    All class have a method to_dict that returns the data of the model as a dict through a GET query to the API.
+
+    Attributes:
+        _cache: basic cache for the API calls based on the url called
+        _client: The client to use for API calls.
+        _model_id: The id of the model.
+    """
+
+    path: str = None
+
+    def __init__(self, model_id: str = None):
+        """Initialize the model."""
+        self._cache: dict = {}
+        self._client = Client()
+        self._model_id = model_id
+
+    @property
+    def _item_path(self) -> str:
+        """Get the path of the model.
+
+        Returns:
+            str: The path of the model.
+        """
+        return f'{self.path}{self._model_id}/'
+
+    @classmethod
+    def from_id(cls: type[T], model_id: str) -> T:
+        """Instantiate a Model from its id.
+
+        Args:
+            model_id (str): id of the model.
+
+        Returns:
+            BaseModel: Instance of the model.
+        """
+        return cls(model_id)
+
+    def get_item(self) -> Result:
+        """Get the data of the model in a dict format.
+
+        Returns:
+            dict: Dict containing the response of the API call.
+        """
+        return DictResult(self._get(self._item_path))
+
+    def _get(self, url: str) -> Any:
+        """Perform a GET request on the API.
+
+        Use a basic cache to avoid calling the API multiple times for the same url.
+
+        Args:
+            url (str): The url to call.
+
+        Returns:
+            Any: The response of the API call.
+        """
+        if url not in self._cache:
+            self._cache[url] = self._client.call_api(url, GET)
+        return self._cache[url]

allphins_sdk-1.0.4/allphins/models/datasource.py

@@ -0,0 +1,61 @@
+"""Datasource model.
+
+```
+from allphins.models import Datasource
+```
+"""
+import pandas as pd
+
+from allphins.client.result import PandasResult
+from allphins.client.result import Result
+from allphins.const import ALLPHINS_API_URL
+from allphins.models.base import BaseModel
+from allphins.utils import validate_uuid4
+
+
+class Datasource(BaseModel):
+    """Datasource model."""
+
+    path = f'{ALLPHINS_API_URL}/datasources/'
+
+    def __init__(self, datasource_id: str):
+        """Instantiate a Datasource from a datasource UUID.
+
+        Args:
+            datasource_id (str): UUID of the datasource.
+
+        Raises:
+            ValueError: If the datasource_id is not a valid UUID.
+        """
+        if not validate_uuid4(datasource_id):
+            raise ValueError(f'{datasource_id} is not a valid UUID.')
+
+        super().__init__(datasource_id)
+
+    @classmethod
+    def from_portfolio_id(cls, portfolio_id: str) -> list['Datasource']:
+        """Instantiate a list of Datasource from a portfolio UUID.
+
+        To get the dict representation of the portfolio datasource,
+        use the datasources_to_dict() method of the portfolio.
+
+        Args:
+            portfolio_id (str): UUID of the portfolio.
+
+        Returns:
+            list[Datasource]: List of datasource.
+        """
+        from allphins.models.portfolio import Portfolio
+
+        return Portfolio.from_id(portfolio_id).datasource_models
+
+    def parquet_risks(self) -> Result:
+        """Get the parquet risks of the datasource as a pandas DataFrame.
+
+        Returns:
+            DataFrame: Pandas DataFrame containing the risks.
+        """
+        response = self._get(f'{self.path}{self._model_id}/parquet_signed_urls/?type=RISKS')
+        risks_urls = response.get('results', [])
+        risks_table = pd.concat(pd.read_parquet(url) for url in risks_urls)
+        return PandasResult(risks_table)

allphins_sdk-1.0.4/allphins/models/policy.py

@@ -0,0 +1,100 @@
+"""Policy model.
+
+```
+from allphins.models import Policy
+```
+"""
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from allphins.client.client import Client
+from allphins.client.result import DictResult
+from allphins.client.result import Result
+from allphins.const import ALLPHINS_API_URL
+from allphins.const import GET
+from allphins.const import ISO_8601
+from allphins.models.base import BaseModel
+
+
+class PolicyStatuses(str, Enum):
+    """Policy status choices."""
+
+    QUOTE = 'quote'
+    WRITTEN = 'written'
+    EXPIRED = 'expired'
+    DECLINED = 'declined'
+    NOT_TAKEN_UP = 'not_taken_up'
+    WORK_IN_PROGRESS = 'work_in_progress'
+    DELETED = 'deleted'
+
+
+class Policy(BaseModel):
+    """Policy model."""
+
+    path = f'{ALLPHINS_API_URL}/policies/'
+
+    @classmethod
+    def live_policies(cls, policy_live_at: Optional[str] = None, filter_rule: Optional[str] = None) -> Result:
+        """Get the live policies matching the policy_live_at date or the filter_rule.
+
+        policy_live_at and filter_rule are mutually exclusive, but at least one of them must be provided.
+
+        Args:
+            policy_live_at (Optional str): Date of the policy live.
+            filter_rule (Optional str): Filter rule to apply ('today', 'previous_1_1', 'next_1_1').
+
+        Returns:
+            list[dict]: List of policies on dict format.
+        """
+        url = ""
+        if policy_live_at and filter_rule:
+            raise ValueError('policy_live_at and filter_rule are mutually exclusive.')
+
+        if not policy_live_at and not filter_rule:
+            raise ValueError('policy_live_at or filter_rule must be provided.')
+
+        if policy_live_at:
+            try:
+                datetime.strptime(policy_live_at, ISO_8601).date()
+                url = f'{cls.path}?policy_live_at={policy_live_at}'
+            except ValueError:
+                raise ValueError(f'{policy_live_at} is not a valid ISO 8601 date.')
+
+        if filter_rule:
+            if filter_rule not in ['today', 'previous_1_1', 'next_1_1']:
+                raise ValueError(f'{filter_rule} is not a valid filter rule.')
+            url = f'{cls.path}?filter_rule={filter_rule}'
+
+        return DictResult(Client().call_api(url, GET))
+
+    @classmethod
+    def from_portfolio_id(cls, portfolio_id: str) -> list['Policy']:
+        """Instantiate a list of policy from a portfolio UUID.
+
+        To get the dict representation of the portfolio policies, use the policies_to_dict() method of the portfolio.
+
+        Args:
+            portfolio_id (str): UUID of the portfolio.
+
+        Returns:
+            list[Policy]: List of policy instances.
+        """
+        from allphins.models.portfolio import Portfolio
+
+        return Portfolio.from_id(portfolio_id).policy_models
+
+    @classmethod
+    def filtered_policies(cls, filters: dict) -> Result:
+        """Get the policy ids matching the filters.
+
+        Args:
+            filters (dict): Filters to apply.
+
+        Returns:
+            Result: List of policy ids.
+        """
+        url = f'{cls.path}filter/?details=true&'
+        for key, value in filters.items():
+            url += f'{key}={value}&'
+        return DictResult(Client().call_api(url[:-1], GET, append_none_pagination=False))

allphins_sdk-1.0.4/allphins/models/portfolio.py

@@ -0,0 +1,90 @@
+"""Portfolio model.
+
+```
+from allphins.models import Portfolio
+```
+"""
+
+from allphins.client.client import Client
+from allphins.client.result import DictResult
+from allphins.client.result import Result
+from allphins.const import ALLPHINS_API_URL
+from allphins.const import GET
+from allphins.models.base import BaseModel
+from allphins.models.datasource import Datasource
+from allphins.models.policy import Policy
+from allphins.utils import validate_uuid4
+
+
+class Portfolio(BaseModel):
+    """Portfolio model."""
+
+    path = f'{ALLPHINS_API_URL}/portfolios/'
+
+    def __init__(self, portfolio_id: str):
+        """Instantiate a Portfolio from a portfolio UUID.
+
+        Args:
+            portfolio_id (str): UUID of the portfolio.
+
+        Raises:
+            ValueError: If the portfolio_id is not a valid UUID.
+        """
+        if not validate_uuid4(portfolio_id):
+            raise ValueError(f'{portfolio_id} is not a valid UUID.')
+
+        super().__init__(portfolio_id)
+
+    @classmethod
+    def all(cls) -> Result:
+        """Get all the portfolios.
+
+        Returns:
+            list[dict]: List of the portfolios dict representation.
+        """
+        return DictResult(Client().call_api(Portfolio.path, GET))
+
+    @property
+    def policy_models(self) -> list[Policy]:
+        """Get the Policy list of the Portfolio.
+
+        To get the data of the policies as a dict, use the policies_to_dict() method.
+
+        Returns:
+            list[Policy]: List of Policy instances.
+        """
+        item = self.get_item().to_json()
+        if isinstance(item, dict):
+            return [Policy.from_id(policy['id']) for policy in item['policies']]
+        raise TypeError('The portfolio is not a dict.')
+
+    @property
+    def datasource_models(self) -> list[Datasource]:
+        """Get the Datasource list of the Portfolio.
+
+        To get the data of the datasources as a dict, use the datasources_to_dict() method.
+
+        Returns:
+            list[Datasource]: List of Datasource instances.
+        """
+        datasources_details = self._get(f'{self._item_path}datasources/')
+        return [Datasource.from_id(datasource['id']) for datasource in datasources_details]
+
+    def policies(self) -> Result:
+        """Get the policies of the portfolio.
+
+        Returns:
+            dict: Dict representation of the policies.
+        """
+        item = self.get_item().to_json()
+        if isinstance(item, dict):
+            return DictResult(item['policies'])
+        raise TypeError('The portfolio is not a dict.')
+
+    def datasources(self) -> Result:
+        """Get the datasources of the portfolio.
+
+        Returns:
+            dict: Dict representation of the datasources.
+        """
+        return DictResult(self._get(f'{self._item_path}datasources/'))

allphins_sdk-1.0.4/allphins/models/risk.py

@@ -0,0 +1,27 @@
+"""Risk model."""
+from allphins.client import Client
+from allphins.client.result import DictResult
+from allphins.client.result import Result
+from allphins.const import ALLPHINS_API_URL
+from allphins.const import POST
+from allphins.models.base import BaseModel
+
+
+class Risk(BaseModel):
+    """Risk model."""
+
+    path = f'{ALLPHINS_API_URL}/risks/list_details/'
+    PAGE_SIZE = 50000
+
+    @classmethod
+    def filtered_risk(cls, filters: dict) -> Result:
+        """Get the filtered risks.
+
+        Args:
+            filters (dict): Filters to apply.
+
+        Returns:
+            Risk: Risk object.
+        """
+        risks = Client().call_api_with_pagination(cls.path, POST, json=filters, page_size=Risk.PAGE_SIZE)
+        return DictResult(risks)

allphins_sdk-1.0.4/allphins/models/scenario.py

@@ -0,0 +1,15 @@
+"""Scenario model.
+
+```
+from allphins.models import Scenario
+```
+"""
+
+from allphins.const import ALLPHINS_API_URL
+from allphins.models.base import BaseModel
+
+
+class Scenario(BaseModel):
+    """Scenario model."""
+
+    path = f'{ALLPHINS_API_URL}/scenarios/'

allphins_sdk-1.0.4/allphins/models/scenario_list.py

@@ -0,0 +1,31 @@
+"""ScenarioList model.
+
+```
+from allphins.models import ScenarioList
+```
+"""
+from typing import Optional
+
+from allphins.const import ALLPHINS_API_URL
+from allphins.models.base import BaseModel
+from allphins.utils import validate_uuid4
+
+
+class ScenarioList(BaseModel):
+    """ScenarioList model."""
+
+    path = f'{ALLPHINS_API_URL}/scenario_lists/'
+
+    def __init__(self, scenario_list_id: Optional[str]):
+        """Instantiate a Scenario list from a scenario list UUID.
+
+        Args:
+            scenario_list_id (str): UUID of the scenario list.
+
+        Raises:
+            ValueError: If the scenario list_id is not a valid UUID.
+        """
+        if not validate_uuid4(scenario_list_id):
+            raise ValueError(f'{scenario_list_id} is not a valid UUID.')
+
+        super().__init__(scenario_list_id)

allphins_sdk-1.0.4/allphins/singleton.py

@@ -0,0 +1,13 @@
+"""Singleton metaclass."""
+
+
+class Singleton(type):
+    """Singleton metaclass."""
+
+    _instances: dict = {}
+
+    def __call__(cls, *args, **kwargs):
+        """Call the class."""
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

allphins_sdk-1.0.4/allphins/status.py

@@ -0,0 +1,72 @@
+"""
+Descriptive HTTP status codes, for code readability.
+
+See RFC 2616 - https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+And RFC 6585 - https://tools.ietf.org/html/rfc6585
+And RFC 4918 - https://tools.ietf.org/html/rfc4918
+"""
+
+HTTP_100_CONTINUE = 100
+HTTP_101_SWITCHING_PROTOCOLS = 101
+HTTP_102_PROCESSING = 102
+HTTP_103_EARLY_HINTS = 103
+HTTP_200_OK = 200
+HTTP_201_CREATED = 201
+HTTP_202_ACCEPTED = 202
+HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
+HTTP_204_NO_CONTENT = 204
+HTTP_205_RESET_CONTENT = 205
+HTTP_206_PARTIAL_CONTENT = 206
+HTTP_207_MULTI_STATUS = 207
+HTTP_208_ALREADY_REPORTED = 208
+HTTP_226_IM_USED = 226
+HTTP_300_MULTIPLE_CHOICES = 300
+HTTP_301_MOVED_PERMANENTLY = 301
+HTTP_302_FOUND = 302
+HTTP_303_SEE_OTHER = 303
+HTTP_304_NOT_MODIFIED = 304
+HTTP_305_USE_PROXY = 305
+HTTP_306_RESERVED = 306
+HTTP_307_TEMPORARY_REDIRECT = 307
+HTTP_308_PERMANENT_REDIRECT = 308
+HTTP_400_BAD_REQUEST = 400
+HTTP_401_UNAUTHORIZED = 401
+HTTP_402_PAYMENT_REQUIRED = 402
+HTTP_403_FORBIDDEN = 403
+HTTP_404_NOT_FOUND = 404
+HTTP_405_METHOD_NOT_ALLOWED = 405
+HTTP_406_NOT_ACCEPTABLE = 406
+HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
+HTTP_408_REQUEST_TIMEOUT = 408
+HTTP_409_CONFLICT = 409
+HTTP_410_GONE = 410
+HTTP_411_LENGTH_REQUIRED = 411
+HTTP_412_PRECONDITION_FAILED = 412
+HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
+HTTP_414_REQUEST_URI_TOO_LONG = 414
+HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
+HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
+HTTP_417_EXPECTATION_FAILED = 417
+HTTP_418_IM_A_TEAPOT = 418
+HTTP_421_MISDIRECTED_REQUEST = 421
+HTTP_422_UNPROCESSABLE_ENTITY = 422
+HTTP_423_LOCKED = 423
+HTTP_424_FAILED_DEPENDENCY = 424
+HTTP_425_TOO_EARLY = 425
+HTTP_426_UPGRADE_REQUIRED = 426
+HTTP_428_PRECONDITION_REQUIRED = 428
+HTTP_429_TOO_MANY_REQUESTS = 429
+HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
+HTTP_500_INTERNAL_SERVER_ERROR = 500
+HTTP_501_NOT_IMPLEMENTED = 501
+HTTP_502_BAD_GATEWAY = 502
+HTTP_503_SERVICE_UNAVAILABLE = 503
+HTTP_504_GATEWAY_TIMEOUT = 504
+HTTP_505_HTTP_VERSION_NOT_SUPPORTED = 505
+HTTP_506_VARIANT_ALSO_NEGOTIATES = 506
+HTTP_507_INSUFFICIENT_STORAGE = 507
+HTTP_508_LOOP_DETECTED = 508
+HTTP_509_BANDWIDTH_LIMIT_EXCEEDED = 509
+HTTP_510_NOT_EXTENDED = 510
+HTTP_511_NETWORK_AUTHENTICATION_REQUIRED = 511

allphins_sdk-1.0.4/allphins/utils.py

@@ -0,0 +1,25 @@
+import uuid
+from uuid import UUID
+
+
+def validate_uuid4(uuid_string: UUID | str) -> bool:
+    """Validate that a UUID string is in fact a valid uuid4.
+
+    Args
+        uuid_string: The string to validate.
+
+    Returns:
+        True if uuid_string is a valid uuid4, False otherwise.
+    """
+    if uuid_string is None:
+        return False
+
+    if isinstance(uuid_string, uuid.UUID):
+        return True
+
+    try:
+        val = UUID(uuid_string, version=4)
+    except ValueError:
+        return False
+
+    return val.hex == uuid_string.replace('-', '')

allphins_sdk-1.0.4/pyproject.toml

@@ -0,0 +1,92 @@
+[tool.isort]
+line_length = 120
+profile = "black"
+ensure_newline_before_comments = true
+force_single_line = true
+
+[tool.black]
+line-length = 120
+target-version = ["py310"]
+skip-string-normalization = true
+force-exclude = '''
+/(
+    migrations
+
+    # black defaults
+    | \.git
+    | \.hg
+    | \.mypy_cache
+    | \.tox
+    | \.venv
+    | _build
+    | buck-out
+    | build
+    | dist
+)/
+'''
+
+[tool.bandit]
+exclude_dirs = ['tests']
+
+[tool.mypy]
+python_version = "3.10"
+pretty = true
+show_column_numbers = true
+show_error_codes = true
+check_untyped_defs = true
+warn_unused_ignores = true
+enable_error_code = "ignore-without-code"
+namespace_packages = true
+follow_imports = "skip"
+
+[[tool.mypy.overrides]]
+module = [
+    "dateparser.*",
+    "dateutil.*",
+    "six.*",
+    "requests.*",
+]
+ignore_missing_imports = true
+
+[tool.flake8]
+max-line-length = 120
+ban-relative-imports = true
+select = ["B", "I", "E", "W", "F", "INP"] 
+ignore = ["E501", "E203", "W503"]
+
+[tool.pydocstyle]
+convention = "google"
+
+[tool.coverage.run]
+disable_warnings = ["no-data-collected"]
+
+[tool.poetry]
+name = "allphins-sdk"
+version = "1.0.4"
+description = ""
+authors = ["Florent <florent@allphins.com>"]
+readme = "README.md"
+packages = [{include = "allphins"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+requests = "^2.31.0"
+pandas = "^2.1.4"
+pyarrow = "^15.0.0"
+tqdm = "^4.66.2"
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+flake8 = "^6.1.0"
+coverage = {extras = ["toml"], version = "^7.3.2"}
+pydocstyle = "^6.3.0"
+mkdocs = "^1.5.3"
+mkdocs-material = "^9.5.2"
+mkdocstrings = {extras = ["python"], version = "^0.24.0"}
+jupyter = "^1.0.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"