From 8414fb4b53e28449c3bf6d29bf93e238b6ac3eb4 Mon Sep 17 00:00:00 2001 From: SeaswimmerTheFsh Date: Thu, 28 Mar 2024 11:28:24 -0400 Subject: [PATCH] fix: pylint fixes --- pyzipline/models.py | 69 +++++++++++++++++++++++++++++++++++++-- pyzipline/rest_adapter.py | 32 ++++++++---------- pyzipline/zipline.py | 2 +- 3 files changed, 82 insertions(+), 21 deletions(-) diff --git a/pyzipline/models.py b/pyzipline/models.py index 2eaf219..031e7f4 100644 --- a/pyzipline/models.py +++ b/pyzipline/models.py @@ -1,8 +1,9 @@ """This is a list of all the models used in PyZipline. They are used to represent the data returned from the Zipline API.""" +import logging from datetime import datetime from typing import Dict, List, Optional, Union -from pydantic import BaseModel, Field +from pydantic import BaseModel, ConfigDict, Field class File(BaseModel): @@ -146,13 +147,47 @@ class Stats(BaseModel): class Embed(BaseModel): + """Object containing a user's embed settings + + Attributes: + color (Optional[str]): String of the embed's color + title (Optional[str]): String of the embed's title + site_name (Optional[str]): String of the embed's site name + description (Optional[str]): String of the embed's description + """ color: Optional[str] = None title: Optional[str] = None siteName: Optional[str] = None description: Optional[str] = None + def __str__(self): + if self.title is None: + return "None" + return self.title class User(BaseModel): + """Object containing user information + + /// admonition | Contains Sensitive Information + type: danger + Please be mindful of how you use/store this object, as it contains sensitive information such as the user's token and TOTP information. + /// + + Attributes: + id (int): Integer ID of the user + uuid (str): String of the user's UUID + username (str): String of the user's username + avatar (Optional[str]): String of the user's avatar, base64 encoded + token (str): String of the user's token + administrator (bool): Boolean of whether the user is an administrator + super_admin (bool): Boolean of whether the user is a super administrator + system_theme (str): String of the user's system theme + embed (Embed): Embed object of the user's embed + totp_secret (Optional[str]): String of the user's TOTP secret + domains (List[str]): List of Strings of the user's domains + oauth (Optional[List[OAuth]]): List of [OAuth](.#pyzipline.models.OAuth) objects + ratelimit (Optional[datetime]): Datetime object of when the user's ratelimit expires + """ id: int uuid: str username: str @@ -170,15 +205,45 @@ class User(BaseModel): return self.username class Versions(BaseModel): + """Object containing the current, stable, and upstream versions of Zipline + + Attributes: + stable (str): String of the stable version + upstream (str): String of the upstream version + current (str): String of the current version + """ stable: str upstream: str current: str - class Version(BaseModel): + """Model containing the current, stable, and upstream versions of Zipline + + Attributes: + is_upstream (bool): Boolean of whether the current version is upstream (`trunk` branch) + update_to_type (str): String of the type of update available, one of 'stable' or 'upstream' + versions (Versions): Versions object containing the current, stable, and upstream versions + """ isUpstream: bool updateToType: str versions: Versions def __str__(self): return self.versions.current + +class ZiplineApiConfig(BaseModel): + """Represents a configuration instance for the ZiplineApi/RestAdapter class. + + Args: + hostname (str): The hostname of your Zipline instance, WITHOUT https or http. + token (str): String used for authentication when making requests. + ssl (bool): Normally set to True, but if your Zipline instance doesn't use SSL/TLS, set this to False. + enforced_signing (bool): Normally set to True, but if having SSL/TLS cert validation issues, can turn off with False. + logger (logging.Logger): If your app has a logger, pass it in here. + """ + model_config = ConfigDict(arbitrary_types_allowed=True) + hostname: str + token: str = '' + ssl: bool = True + enforced_signing: bool = True + logger: logging.Logger = logging.getLogger(__name__) diff --git a/pyzipline/rest_adapter.py b/pyzipline/rest_adapter.py index 28055cc..0eb8d6c 100644 --- a/pyzipline/rest_adapter.py +++ b/pyzipline/rest_adapter.py @@ -6,36 +6,32 @@ import requests from urllib3 import disable_warnings from pyzipline.exceptions import HTTPFailure, PyZiplineError -from pyzipline.models import Result +from pyzipline.models import Result, ZiplineApiConfig class RestAdapter: """Constructor for RestAdapter 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. + config (ZiplineApiConfig): Configuration object for the ZiplineApi class Raises: ValueError: Raised when the keyword arguments passed to the class constructor conflict. """ - def __init__(self, hostname: str, token: str = '', ssl: bool = True, enforced_signing: bool = True, logger: logging.Logger = None): - self._url = f"http{'s' if ssl else ''}://{hostname}/api/" - self._token = token - self._ssl = ssl - self._enforced_signing = enforced_signing - self._logger = logger or logging.getLogger(__name__) + def __init__(self, config = ZiplineApiConfig): + self._url = f"http{'s' if config.ssl else ''}://{config.hostname}/api/" + self._token = config.token + self._ssl = config.ssl + self._enforced_signing = config.enforced_signing + self._logger = config.logger or logging.getLogger(__name__) - if ssl is False and enforced_signing is True: + if config.ssl is False and config.enforced_signing is True: raise ValueError("Cannot enforce signing without SSL") - if not ssl and not enforced_signing: + if not config.ssl and not config.enforced_signing: disable_warnings() - def _do(self, http_method: str, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: + def _do(self, http_method: str, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments """Internal method to make a request to the Zipline server. You shouldn't use this directly. Args: @@ -82,7 +78,7 @@ class RestAdapter: return Result(success=is_success, status_code=response.status_code, message=data_out['error'], data=data_out) - def delete(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, timeout: float = 60) -> Result: + def delete(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments """Make a DELETE request to the Zipline server. You should almost never have to use this directly. Args: @@ -109,7 +105,7 @@ class RestAdapter: """ return self._do(http_method='GET', endpoint=endpoint, headers=headers, params=params, timeout=timeout) - def patch(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: + def patch(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments """Make a PATCH request to the Zipline server. You should almost never have to use this directly. Args: @@ -124,7 +120,7 @@ class RestAdapter: """ return self._do(http_method='PATCH', endpoint=endpoint, headers=headers, params=params, json=json, files=files, timeout=timeout) - def post(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: + def post(self, endpoint: str, headers: dict = None, params: dict = None, json: dict = None, files: dict = None, timeout: float = 60) -> Result: # pylint: disable=too-many-arguments """Make a POST request to the Zipline server. You should almost never have to use this directly. Args: diff --git a/pyzipline/zipline.py b/pyzipline/zipline.py index 54846db..6bf5608 100644 --- a/pyzipline/zipline.py +++ b/pyzipline/zipline.py @@ -42,7 +42,7 @@ class ZiplineApi: self, config: ZiplineApiConfig ): - self._rest_adapter = RestAdapter(hostname=config.hostname, token=config.token, ssl=config.ssl, enforced_signing=config.enforced_signing, logger=config.logger) + self._rest_adapter = RestAdapter(config) def create_invite(self, expiry: timedelta = timedelta(days=1), count: int = 1) -> Union[Invite, List[Invite]]: """Create an invite code