Library typing is fixed, new version

Author: AbstractUmbra

mystbin/__init__.py

@@ -36,5 +36,5 @@ class VersionInfo(NamedTuple):
     serial: int
 
 
-__version__ = "2.1.3"
-version_info: VersionInfo = VersionInfo(major=2, minor=1, micro=3, releaselevel="final", serial=0)
+__version__ = "2.2.0"
+version_info: VersionInfo = VersionInfo(major=2, minor=2, micro=0, releaselevel="final", serial=0)

mystbin/__main__.py

@@ -21,10 +21,12 @@
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 """
+from __future__ import annotations
 
 import argparse
 import platform
 import sys
+from typing import List, Tuple
 
 import aiohttp
 import pkg_resources
@@ -38,39 +40,43 @@
 import mystbin
 
 
-def show_version():
-    entries = []
+def show_version() -> None:
+    entries: List[str] = []
 
     entries.append("- 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")
         if pkg:
             entries.append("    - mystbin.py pkg_resources: v{0}".format(pkg.version))
 
     entries.append("- aiohttp v{0.__version__}".format(aiohttp))
+
     if requests is not None:
         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))
 
 
-def parse_args():
+def parse_args() -> Tuple[argparse.ArgumentParser, argparse.Namespace]:
     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")
     parser.set_defaults(func=core)
 
     return parser, parser.parse_args()
 
 
-def core(parser, args):
+def core(_: argparse.ArgumentParser, args: argparse.Namespace) -> None:
     if args.version:
         show_version()
 
 
-def main():
+def main() -> None:
     parser, args = parse_args()
     args.func(parser, args)
 

mystbin/client.py

@@ -24,7 +24,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Awaitable, Optional, Union
+from typing import TYPE_CHECKING, Coroutine, Optional, Union
 
 import aiohttp
 
@@ -45,41 +45,37 @@ class HTTPClient:
 
     Attributes
     ----------
-    api_key: Optional[:class:`str`]
-        Your private API token to access the Mystb.in API.
-        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")
+    __slots__ = (
+        "session",
+        "_are_we_async",
+    )
 
     def __init__(
         self,
         *,
-        api_key: str = "",
         session: Optional[Union[aiohttp.ClientSession, requests.Session]] = None,
     ) -> None:
-        self.api_key = api_key
         self._are_we_async = session is None or isinstance(session, aiohttp.ClientSession)
-        self.session = session
+        self.session = session  # type: ignore
 
-    async def _generate_async_session(self) -> aiohttp.ClientSession:
+    async def _generate_async_session(self) -> None:
         """
         This method will create a new and blank `aiohttp.ClientSession` instance for use.
         This method should not be called if a session is passed to the constructor.
         """
-        self.session = aiohttp.ClientSession()
+        self.session: aiohttp.ClientSession = aiohttp.ClientSession()
 
-        return self.session
-
-    def post(self, content: str, syntax: str = None) -> Union[Paste, Awaitable]:
+    def post(self, content: str, syntax: str = None) -> Union[Paste, Coroutine[None, None, Paste]]:
         """
         This will post to the Mystb.in API and return the url.
         Can pass an optional suffix for the syntax highlighting.
 
         Parameters
-        ----------
+        -----------
         content: :class:`str`
             The content you are posting to the Mystb.in API.
         syntax: :class:`str`
@@ -90,16 +86,19 @@ def post(self, content: str, syntax: str = None) -> Union[Paste, Awaitable]:
         return self._perform_sync_post(content, syntax)
 
     def _perform_sync_post(self, content: str, syntax: str = None) -> Paste:
-        """ Sync post request. """
+        assert not isinstance(self.session, aiohttp.ClientSession)
+
         payload = {"meta": [{"index": 0, "syntax": syntax}]}
+
+        assert self.session is not None and not isinstance(self.session, aiohttp.ClientSession)
+
         response: requests.Response = self.session.post(
             API_BASE_URL,
             files={
                 "data": content,
                 "meta": (None, json.dumps(payload), "application/json"),
             },
             timeout=CLIENT_TIMEOUT,
-            headers={"Authorization": self.api_key},
         )
 
         if response.status_code not in [200, 201]:
@@ -108,9 +107,10 @@ def _perform_sync_post(self, content: str, syntax: str = None) -> Paste:
         return Paste(response.json(), syntax)
 
     async def _perform_async_post(self, content: str, syntax: str = None) -> Paste:
-        """ Async post request. """
         if not self.session and self._are_we_async:
-            self.session = await self._generate_async_session()
+            await self._generate_async_session()
+
+        assert self.session is not None and isinstance(self.session, aiohttp.ClientSession)
 
         multi_part_write = aiohttp.MultipartWriter()
         paste_content = multi_part_write.append(content)
@@ -122,17 +122,18 @@ async def _perform_async_post(self, content: str, syntax: str = None) -> Paste:
             API_BASE_URL,
             data=multi_part_write,
             timeout=aiohttp.ClientTimeout(CLIENT_TIMEOUT),
-            headers={"Authorization": self.api_key},
         ) as response:
             status_code = response.status
             response_text = await response.text()
-            if status_code not in (200,):
+
+            if status_code != 200:
                 raise APIError(status_code, response_text)
+
             response_data = await response.json()
 
         return Paste(response_data, syntax)
 
-    def get(self, paste_id: str) -> Union[PasteData, Awaitable]:
+    def get(self, paste_id: str) -> Union[PasteData, Coroutine[None, None, PasteData]]:
         """
         This will perform a GET request against the Mystb.in API and return the url.
         Must be passed a valid paste ID or URL.
@@ -155,19 +156,20 @@ def get(self, paste_id: str) -> Union[PasteData, Awaitable]:
         return self._perform_async_get(paste_id)
 
     def _perform_sync_get(self, paste_id: str) -> PasteData:
-        """ Sync get request. """
-        response: requests.Response = self.session.get(f"{API_BASE_URL}/{paste_id}", timeout=CLIENT_TIMEOUT)
+        assert self.session is not None and not isinstance(self.session, aiohttp.ClientSession)
 
-        if response.status_code not in (200,):
-            raise BadPasteID("This is an invalid Mystb.in paste ID.")
+        with self.session.get(f"{API_BASE_URL}/{paste_id}", timeout=CLIENT_TIMEOUT) as response:
+            if response.status_code not in (200,):
+                raise BadPasteID("This is an invalid Mystb.in paste ID.")
 
         paste_data = response.json()
         return PasteData(paste_id, paste_data)
 
     async def _perform_async_get(self, paste_id: str) -> PasteData:
-        """ Async get request. """
         if not self.session:
-            self.session: aiohttp.ClientSession = await self._generate_async_session()
+            await self._generate_async_session()
+
+        assert self.session is not None and isinstance(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,):
@@ -176,7 +178,7 @@ async def _perform_async_get(self, paste_id: str) -> PasteData:
 
         return PasteData(paste_id, paste_data)
 
-    async def close(self):
-        """ Async only - close the session. """
+    async def close(self) -> None:
+        """Async only - close the session."""
         if self.session and isinstance(self.session, aiohttp.ClientSession):
             await self.session.close()

mystbin/errors.py

@@ -26,11 +26,11 @@
 
 
 class BadPasteID(ValueError):
-    """ Bad Paste ID. """
+    """Bad Paste ID."""
 
 
 class MystbinException(Exception):
-    """ Error when interacting with Mystbin. """
+    """Error when interacting with Mystbin."""
 
 
 class APIError(MystbinException):
@@ -48,8 +48,8 @@ class APIError(MystbinException):
     __slots__ = ("status_code", "message")
 
     def __init__(self, status_code: int, message: str):
-        self.status_code = status_code
-        self.message = message
+        self.status_code: int = status_code
+        self.message: str = message
 
     def __repr__(self) -> str:
         return f"<MystbinError status_code={self.status_code} message={self.message}>"

mystbin/objects.py

@@ -24,6 +24,7 @@
 
 import datetime
 from textwrap import dedent
+from typing import Any, Dict, Optional
 
 from .constants import PASTE_BASE
 
@@ -45,9 +46,9 @@ 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.syntax = syntax
+        self.paste_id: str = json_data["pastes"][0]["id"]
+        self.nick: Optional[str] = json_data["pastes"][0]["nick"]
+        self.syntax: Optional[str] = syntax
 
     def __str__(self) -> str:
         return self.url
@@ -61,7 +62,7 @@ def url(self) -> str:
         syntax = f".{self.syntax}" if self.syntax else ""
         return PASTE_BASE.format(self.paste_id, syntax)
 
-    def with_syntax(self, new_syntax: str) -> str:
+    def with_syntax(self, new_syntax: Optional[str]) -> str:
         """
         Changes the syntax of the current Paste to `new_syntax`
 
@@ -86,9 +87,9 @@ class PasteData:
         The content returned from the paste.
     paste_syntax: :class:`str`
         The syntax you specified that this Paste is in.
-    paste_nick: :class:`str`
+    paste_nick: Optional[:class:`str`]
         The nick set for this paste on the API.
-    paste_date: :class:`datetime.datetime`
+    paste_date: :class:`str`
         The date this paste was created on the API.
     """
 
@@ -101,13 +102,13 @@ class PasteData:
         "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"]
+    def __init__(self, paste_id: str, paste_data: Dict[str, Any]):
+        self.paste_id: str = paste_id
+        self._paste_data: Dict[str, Any] = paste_data
+        self.paste_content: str = paste_data["data"]
+        self.paste_syntax: str = paste_data["syntax"]
+        self.paste_nick: Optional[str] = paste_data["nick"]
+        self.paste_date: str = paste_data["created_at"]
 
     def __str__(self) -> str:
         return self.content