PyZipline/pyzipline/zipline.py

import logging
from pyzipline.rest_adapter import RestAdapter
from pyzipline.errors import PyZiplineError, FeatureDisabledError
from pyzipline.models import *

class ZiplineApi:
    """Represents an instance of the Zipline API.

    All API requests should be made through this class.

    Args:
        hostname (str): The hostname of your Zipline instance, WITHOUT https or http.
        token (str = None): String used for authentication when making requests.
        ssl (bool = True): Normally set to True, but if your Zipline instance doesn't use SSL/TLS, set this to False.
        enforced_signing (bool = True): Normally set to True, but if having SSL/TLS cert validation issues, can turn off with False.
        logger (logging.Logger = None): If your app has a logger, pass it in here.
    """
    def __init__(
        self,
        hostname: str,
        token: str = '',
        ssl: bool = True,
        enforced_signing: bool = True,
        logger: logging.Logger = None
    ):
        self._rest_adapter = RestAdapter(hostname=hostname, token=token, ssl=ssl, enforced_signing=enforced_signing, logger=logger)

    def get_user(self, user_id: int) -> User:
        """Get a user by ID

        Args:
            user_id (int): Integer ID of the user to retrieve

        Returns:
            :class:`pyzipline.models.User`: The user with the given ID
        """
        result = self._rest_adapter.get(endpoint=f"user/{user_id}")
        return User(**result.data)

    def get_self(self) -> User:
        """Get the currently authenticated user

        Returns:
            :class:`pyzipline.models.User`: The currently authenticated user
        """
        result = self._rest_adapter.get(endpoint=f"user")
        return User(**result.data)

    def check_user_exists(self, username: str, invite: str = None) -> bool:
        """Check if a user exists by username

        Args:
            username (str): Username to check
            invite (str = None): Invite code to use, only required if registration without invites is disabled

        Raises:
            FeatureDisabledError: Raised when registration or invites are disabled on the Zipline instance
            PyZiplineError: Raised

        Returns:
            bool: True if user exists, False if not
        """
        params = {'username': username} if invite is None else {'username': username, 'code': invite}
        result: Result = self._rest_adapter.get(endpoint=f"user/check", params=params)
        if result.status_code == 200:
            return bool(result.data['success'])
        elif result.message == 'user resistration is disabled' or result.message == 'invites are disabled':
            raise FeatureDisabledError(result.message)
        elif result.message == 'username already exists':
            return True
        elif result.message == 'invalid invite code':
            raise ValueError(result.message)
        else:
            raise PyZiplineError(result.message)