Deps bump, black formatted, gh actions test, typo fix on Issue template

Author: AbstractUmbra

.github/ISSUE_TEMPLATE/bug_report.md

@@ -17,7 +17,7 @@ assignees: ''
 <!-- A clear and concise description of what the bug is. -->
 
 ## To Reproduce
-<!-- Steps to take to reproduce this issue. Please describe then in details and **feel free to include screenshots** -->
+<!-- Steps to take to reproduce this issue. Please describe then in details and **feel free to include screenshots**. -->
 
 ## Expected behavior
 <!-- A clear and concise description of what you expected to happen. -->

.github/workflows/analyze.yml

@@ -0,0 +1,22 @@
+name: Analyze
+
+on:
+  pull_request:
+  push:
+  schedule:
+  - cron: "0 0 * * 0"
+
+jobs:
+  job:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Init CodeQL
+      uses: github/codeql-action/init@v1
+
+    - name: Analyze
+      uses: github/codeql-action/analyze@v1

.github/workflows/lint.yml

@@ -0,0 +1,18 @@
+name: Linting
+
+on: [pull_request, push]
+
+jobs:
+  linter:
+    name: Linting
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v2
+
+      - name: Lint
+        uses: github/super-linter@v3
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VALIDATE_PYTHON_BLACK: true

.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish to PyPi
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: [3.8, 3.9]
+
+      - name: Set up Poetry
+        uses: Gr1N/setup-poetry@v4
+
+      - name: Install Python deps
+        run: |
+          poetry install --no-dev
+
+      - name: Build & release
+        run: |
+          poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }}
+          poetry publish --build

mystbin/__init__.py

@@ -24,11 +24,9 @@
 
 from collections import namedtuple
 
-from .client import Client
+from .client import HTTPClient as Client
 from .errors import *
 
 __version__ = "1.0.1"
-VersionInfo = namedtuple(
-    "VersionInfo", "major minor micro releaselevel serial")
-version_info = VersionInfo(major=1, minor=0, micro=1,
-                           releaselevel='final', serial=0)
+VersionInfo = namedtuple("VersionInfo", "major minor micro releaselevel serial")
+version_info = VersionInfo(major=1, minor=0, micro=1, releaselevel="final", serial=0)

mystbin/__main__.py

@@ -41,30 +41,36 @@ def show_version():
     entries = []
 
     entries.append(
-        '- Python v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}'.format(sys.version_info))
+        "- Python v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}".format(
+            sys.version_info
+        )
+    )
     version_info = mystbin.version_info
     entries.append(
-        '- mystbin.py v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}'.format(version_info))
-    if version_info.releaselevel != 'final':
-        pkg = pkg_resources.get_distribution('mystbin.py')
+        "- mystbin.py v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}".format(
+            version_info
+        )
+    )
+    if version_info.releaselevel != "final":
+        pkg = pkg_resources.get_distribution("mystbin.py")
         if pkg:
-            entries.append(
-                '    - mystbin.py pkg_resources: v{0}'.format(pkg.version))
+            entries.append("    - mystbin.py pkg_resources: v{0}".format(pkg.version))
 
-    entries.append('- aiohttp v{0.__version__}'.format(aiohttp))
+    entries.append("- aiohttp v{0.__version__}".format(aiohttp))
     if requests is not None:
-        entries.append('  - [requests] v{0.__version__}'.format(requests))
+        entries.append("  - [requests] v{0.__version__}".format(requests))
     uname = platform.uname()
-    entries.append(
-        '- system info: {0.system} {0.release} {0.version}'.format(uname))
-    print('\n'.join(entries))
+    entries.append("- system info: {0.system} {0.release} {0.version}".format(uname))
+    print("\n".join(entries))
 
 
 def parse_args():
     parser = argparse.ArgumentParser(
-        prog='mystbin', description='Tools for helping with mystbin.py')
-    parser.add_argument('-v', '--version', action='store_true',
-                        help='shows the wrapper version')
+        prog="mystbin", description="Tools for helping with mystbin.py"
+    )
+    parser.add_argument(
+        "-v", "--version", action="store_true", help="shows the wrapper version"
+    )
     parser.set_defaults(func=core)
 
     return parser, parser.parse_args()

mystbin/client.py

@@ -22,65 +22,73 @@
 DEALINGS IN THE SOFTWARE.
 """
 
-import asyncio
 import json
-from typing import TYPE_CHECKING, Awaitable, Callable, Optional, Type, Union
+from typing import TYPE_CHECKING, Awaitable, Optional, Type, Union
 
 import aiohttp
 
 if TYPE_CHECKING:
     import requests
 
-from .constants import *
-from .errors import *
-from .objects import *
+from .constants import API_BASE_URL, CLIENT_TIMEOUT, MB_URL_RE
+from .errors import APIError, BadPasteID
+from .objects import Paste, PasteData
 
-__all__ = ("Client", )
+__all__ = ("HTTPClient",)
 
 
-class Client:
+class HTTPClient:
     """
     Client for interacting with the Mystb.in API.
 
     Attributes
     ----------
     api_key: Optional[:class:`str`]
         Your private API token to access the Mystb.in API.
-        Can be obtained via: #TODO
+        Currently unobtainable.
     session: Optional[Union[:class:`aiohttp.ClientSession`, :class:`requests.Session`]]
         Optional session to be passed to the creation of the client.
     """
+
     __slots__ = ("api_key", "session", "_are_we_async")
 
     def __init__(
-        self, *,
+        self,
+        *,
         api_key: str = None,
-        session: Optional[Union[aiohttp.ClientSession,
-                                Type["requests.Session"]]] = None
+        session: Optional[Union[aiohttp.ClientSession, Type["requests.Session"]]] = None,
     ) -> None:
         self.api_key = api_key
         self._are_we_async = session is None or isinstance(
-            session, aiohttp.ClientSession)
-        self.session = self._generate_sync_session(
-            session) if not self._are_we_async else None
+            session, aiohttp.ClientSession
+        )
+        self.session = (
+            self._generate_sync_session(session) if not self._are_we_async else None
+        )
 
-    def _generate_sync_session(self, session: Type["requests.Session"]) -> Type["requests.Session"]:
+    def _generate_sync_session(
+        self, session: Type["requests.Session"]
+    ) -> Type["requests.Session"]:
         """ We will update a :class:`requests.Session` instance with the auth we require. """
         # the passed session was found to be 'sync'.
         if self.api_key:
             session.headers.update(
-                {"Authorization": self.api_key, "User-Agent": f"Mystbin.py"})
+                {"Authorization": self.api_key, "User-Agent": "Mystbin.py"}
+            )
 
         return session
 
-    async def _generate_async_session(self, session: Optional[aiohttp.ClientSession] = None) -> aiohttp.ClientSession:
+    async def _generate_async_session(
+        self, session: Optional[aiohttp.ClientSession] = None
+    ) -> aiohttp.ClientSession:
         """ We will update (or create) a :class:`aiohttp.ClientSession` instance with the auth we require. """
         if not session:
             session = aiohttp.ClientSession(raise_for_status=False)
 
         if self.api_key:
             session._default_headers.update(
-                {"Authorization": self.api_key, "User-Agent": f"Mystbin.py"})
+                {"Authorization": self.api_key, "User-Agent": "Mystbin.py"}
+            )
 
         session._timeout = aiohttp.ClientTimeout(CLIENT_TIMEOUT)
         return session
@@ -103,9 +111,15 @@ def post(self, content: str, syntax: str = None) -> Union[Paste, Awaitable]:
 
     def _perform_sync_post(self, content: str, syntax: str = None) -> Paste:
         """ Sync post request. """
-        payload = {'meta': [{'index': 0, 'syntax': syntax}]}
-        response: Type["requests.Response"] = self.session.post(API_BASE_URL, files={
-            'data': content, 'meta': (None, json.dumps(payload), 'application/json')}, timeout=CLIENT_TIMEOUT)
+        payload = {"meta": [{"index": 0, "syntax": syntax}]}
+        response: Type["requests.Response"] = self.session.post(
+            API_BASE_URL,
+            files={
+                "data": content,
+                "meta": (None, json.dumps(payload), "application/json"),
+            },
+            timeout=CLIENT_TIMEOUT,
+        )
 
         if response.status_code not in [200, 201]:
             raise APIError(response.status_code, response.text)
@@ -121,14 +135,14 @@ async def _perform_async_post(self, content: str, syntax: str = None) -> Paste:
         paste_content = multi_part_write.append(content)
         paste_content.set_content_disposition("form-data", name="data")
         paste_content = multi_part_write.append_json(
-            {'meta': [{'index': 0, 'syntax': syntax}]}
+            {"meta": [{"index": 0, "syntax": syntax}]}
         )
         paste_content.set_content_disposition("form-data", name="meta")
 
         async with self.session.post(API_BASE_URL, data=multi_part_write) as response:
             status_code = response.status
             response_text = await response.text()
-            if status_code not in (200, ):
+            if status_code not in (200,):
                 raise APIError(status_code, response_text)
             response_data = await response.json()
 
@@ -149,8 +163,8 @@ def get(self, paste_id: str) -> Union[PasteData, Awaitable]:
         if not paste_id_match:
             raise BadPasteID("This is an invalid Mystb.in paste ID.")
 
-        paste_id = paste_id_match.group('ID')
-        syntax = paste_id_match.group('syntax')
+        paste_id = paste_id_match.group("ID")
+        syntax = paste_id_match.group("syntax")
 
         if not self._are_we_async:
             return self._perform_sync_get(paste_id, syntax)
@@ -160,9 +174,10 @@ def get(self, paste_id: str) -> Union[PasteData, Awaitable]:
     def _perform_sync_get(self, paste_id: str, syntax: str = None) -> PasteData:
         """ Sync get request. """
         response: Type["requests.Response"] = self.session.get(
-            f"{API_BASE_URL}/{paste_id}", timeout=CLIENT_TIMEOUT)
+            f"{API_BASE_URL}/{paste_id}", timeout=CLIENT_TIMEOUT
+        )
 
-        if response.status_code not in (200, ):
+        if response.status_code not in (200,):
             raise BadPasteID("This is an invalid Mystb.in paste ID.")
 
         paste_data = response.json()
@@ -173,8 +188,12 @@ async def _perform_async_get(self, paste_id: str, syntax: str = None) -> PasteDa
         if not self.session:
             self.session: aiohttp.ClientSession = await self._generate_async_session()
 
-        async with self.session.get(f"{API_BASE_URL}/{paste_id}", timeout=aiohttp.ClientTimeout(CLIENT_TIMEOUT)) as response:
-            if response.status not in (200, ):
+        self.session: aiohttp.ClientSession
+
+        async with self.session.get(
+            f"{API_BASE_URL}/{paste_id}", timeout=aiohttp.ClientTimeout(CLIENT_TIMEOUT)
+        ) as response:
+            if response.status not in (200,):
                 raise BadPasteID("This is an invalid Mystb.in paste ID.")
             paste_data = await response.json()
 

mystbin/constants.py

@@ -33,4 +33,5 @@
 
 # grab the paste id: https://regex101.com/r/qkluDh/6
 MB_URL_RE = compile(
-    r"(?:(?:https?://)?mystb\.in/)?(?P<ID>[a-zA-Z]+)(?:\.(?P<syntax>[a-zA-Z0-9]+))?")
+    r"(?:(?:https?://)?mystb\.in/)?(?P<ID>[a-zA-Z]+)(?:\.(?P<syntax>[a-zA-Z0-9]+))?"
+)

mystbin/objects.py

@@ -45,8 +45,8 @@ class Paste:
     __slots__ = ("paste_id", "nick", "syntax")
 
     def __init__(self, json_data: dict, syntax: str = None):
-        self.paste_id = json_data['pastes'][0]['id']
-        self.nick = json_data['pastes'][0]['nick']
+        self.paste_id = json_data["pastes"][0]["id"]
+        self.nick = json_data["pastes"][0]["nick"]
         self.syntax = syntax
 
     def __str__(self) -> str:
@@ -92,16 +92,22 @@ class PasteData:
         The date this paste was created on the API.
     """
 
-    __slots__ = ("paste_id", "_paste_data", "paste_content",
-                 "paste_syntax", "paste_nick", "paste_date")
+    __slots__ = (
+        "paste_id",
+        "_paste_data",
+        "paste_content",
+        "paste_syntax",
+        "paste_nick",
+        "paste_date",
+    )
 
     def __init__(self, paste_id: str, paste_data: dict):
         self.paste_id = paste_id
         self._paste_data = paste_data
-        self.paste_content = paste_data['data']
-        self.paste_syntax = paste_data['syntax']
-        self.paste_nick = paste_data['nick']
-        self.paste_date = paste_data['created_at']
+        self.paste_content = paste_data["data"]
+        self.paste_syntax = paste_data["syntax"]
+        self.paste_nick = paste_data["nick"]
+        self.paste_date = paste_data["created_at"]
 
     def __str__(self) -> str:
         return self.content