github-bot-api 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

github_bot_api/__init__.py

@@ -1,9 +1,8 @@
-
-__author__ = 'Niklas Rosenstein <nrosenstein@palantir.com>'
-__version__ = '0.5.1'
+__author__ = "Niklas Rosenstein <nrosenstein@palantir.com>"
+__version__ = "0.6.0"
 
 from .app import GithubApp
-from .event import Event
+from .event import Event, accept_event
 from .webhook import Webhook
 
-__all__ = ['GithubApp', 'Event', 'Webhook']
+__all__ = ["GithubApp", "Event", "accept_event", "Webhook"]

github_bot_api/app.py

@@ -1,4 +1,3 @@
-
 """
 Registry for GitHub event handlers.
 """
@@ -9,205 +8,181 @@ import sys
 import threading
 import typing as t
 
-import deprecated
 import requests
-import urllib3  # type: ignore[import]
-from nr.functional import coalesce
+import urllib3
 
 from . import __version__
 from .token import InstallationTokenSupplier, JwtSupplier, TokenInfo
+from .utils.functions import coalesce
 
-T = t.TypeVar('T')
+T = t.TypeVar("T")
 logger = logging.getLogger(__name__)
-user_agent = f'python/{sys.version.split()[0]} github-bot-api/{__version__}'
+user_agent = f"python/{sys.version.split()[0]} github-bot-api/{__version__}"
 
 if t.TYPE_CHECKING:
-  import github
+    import github
 
 
 @dataclasses.dataclass
 class GithubClientSettings:
-  """
-  Settings for constructing a #github.Github client object.
-  """
-
-  base_url: t.Optional[str] = None
-  user_agent: t.Optional[str] = None
-  timeout: t.Optional[float] = None
-  per_page: t.Optional[int] = None
-  verify: t.Optional[bool] = None
-  retry: t.Optional[urllib3.Retry] = None
-
-  def update(self, other: 'GithubClientSettings') -> 'GithubClientSettings':
-    result = GithubClientSettings()
-    for field in dataclasses.fields(self):
-      value = getattr(other, field.name)
-      if value is None:
-        value = getattr(self, field.name)
-      setattr(result, field.name, value)
-    return result
-
-  def make_client(self, login_or_token: t.Optional[str] = None, jwt: t.Optional[str] = None) -> 'github.Github':
-    import github, github.MainClass
-    return github.Github(
-      login_or_token=login_or_token,
-      jwt=jwt,
-      base_url=self.base_url or github.MainClass.DEFAULT_BASE_URL,  # type: ignore[attr-defined]
-      user_agent=self.user_agent or "PyGithub/Python",
-      timeout=coalesce(self.timeout, github.MainClass.DEFAULT_TIMEOUT),  # type: ignore[attr-defined]
-      per_page=coalesce(self.per_page, github.MainClass.DEFAULT_PER_PAGE),  # type: ignore[attr-defined]
-      verify=coalesce(self.verify, True),
-      retry=self.retry)
+    """
+    Settings for constructing a #github.Github client object.
+    """
+
+    base_url: t.Optional[str] = None
+    user_agent: t.Optional[str] = None
+    timeout: t.Optional[int] = None
+    per_page: t.Optional[int] = None
+    verify: t.Optional[bool] = None
+    retry: t.Optional[urllib3.Retry] = None
+
+    def update(self, other: "GithubClientSettings") -> "GithubClientSettings":
+        result = GithubClientSettings()
+        for field in dataclasses.fields(self):
+            value = getattr(other, field.name)
+            if value is None:
+                value = getattr(self, field.name)
+            setattr(result, field.name, value)
+        return result
+
+    def make_client(self, login_or_token: t.Optional[str] = None, jwt: t.Optional[str] = None) -> "github.Github":
+        import github
+        import github.Consts
+
+        return github.Github(
+            login_or_token=login_or_token,
+            jwt=jwt,
+            base_url=self.base_url or github.Consts.DEFAULT_BASE_URL,
+            user_agent=self.user_agent or "PyGithub/Python",
+            timeout=coalesce(self.timeout, github.Consts.DEFAULT_TIMEOUT),
+            per_page=coalesce(self.per_page, github.Consts.DEFAULT_PER_PAGE),
+            verify=coalesce(self.verify, True),
+            retry=self.retry,
+        )
 
 
 @dataclasses.dataclass
 class GithubApp:
-  """
-  Represents a GitHub application and all the required details.
-
-  # Example
-
-  ```py
-  import os
-  from github_bot_api import GithubApp
-
-  with open(os.environ['PRIVATE_KEY_FILE']) as fp:
-    private_key = fp.read()
-
-  app = GithubApp(
-    user_agent='my-bot/0.0.0',
-    app_id=int(os.environ['APP_ID']),
-    private_key=private_key)
-
-  print(app.app_client().get_app().owner)
-  ```
-  """
-
-  PUBLIC_GITHUB_V3_API_URL = 'https://api.github.com'
-
-  #: User agent of the application. This will be respected in #get_user_agent().
-  user_agent: str
-
-  #: GitHub Application ID.
-  app_id: int
-
-  #: RSA private key to sign the JWT with.
-  private_key: str
-
-  #: GitHub API base URL. Defaults to the public GitHub API.
-  v3_api_url: str = PUBLIC_GITHUB_V3_API_URL
-
-  def __post_init__(self):
-    self._jwt_supplier = JwtSupplier(self.app_id, self.private_key)
-    self._lock = threading.Lock()
-    self._installation_tokens: t.Dict[int, InstallationTokenSupplier] = {}
-
-  def _get_base_github_client_settings(self) -> GithubClientSettings:
-    return GithubClientSettings(self.v3_api_url, self.get_user_agent())
-
-  def get_user_agent(self, installation_id: t.Optional[int] = None) -> str:
     """
-    Create a user agent string for the PyGithub client, including the installation if specified.
+    Represents a GitHub application and all the required details.
     """
 
-    user_agent = f'{self.user_agent} PyGithub/python (app_id={self.app_id}'
-    if installation_id:
-      user_agent += f', installation_id={installation_id})'
-    return user_agent
+    PUBLIC_GITHUB_V3_API_URL = "https://api.github.com"
 
-  @property
-  def jwt(self) -> TokenInfo:
-    """
-    Returns the JWT for your GitHub application. The JWT is the token to use with GitHub application APIs.
-    """
+    user_agent: str
+    """User agent of the application. This will be respected in #get_user_agent()."""
 
-    return self._jwt_supplier()
+    app_id: int
+    """GitHub Application ID."""
 
-  @property
-  def jwt_supplier(self) -> JwtSupplier:
-    """
-    Returns a new #JwtSupplier that is used for generating JWT tokens for your GitHub application.
-    """
+    private_key: str
+    """RSA private key to sign the JWT with."""
 
-    return JwtSupplier(self.app_id, self.private_key)
+    v3_api_url: str = PUBLIC_GITHUB_V3_API_URL
+    """GitHub API base URL. Defaults to the public GitHub API."""
 
-  @property  # type: ignore[misc]
-  @deprecated.deprecated(reason='use GithubApp.app_client() instead', version='0.4.0')
-  def client(self) -> 'github.Github':
-    """
-    Use #app_client() instead.
-    """
+    def __post_init__(self):
+        self._jwt_supplier = JwtSupplier(self.app_id, self.private_key)
+        self._lock = threading.Lock()
+        self._installation_tokens: t.Dict[int, InstallationTokenSupplier] = {}
 
-    return self.app_client()
+    def _get_base_github_client_settings(self) -> GithubClientSettings:
+        return GithubClientSettings(self.v3_api_url, self.get_user_agent())
 
-  def app_client(self, settings: t.Union[GithubClientSettings, t.Dict[str, t.Any], None] = None) -> 'github.Github':
-    """
-    Returns a PyGithub client for your GitHub application.
+    def get_user_agent(self, installation_id: t.Optional[int] = None) -> str:
+        """
+        Create a user agent string for the PyGithub client, including the installation if specified.
+        """
 
-    Note that the client's token will expire after 10 minutes and you will have to create a new client or update the
-    client's token with the value returned by #jwt. It is recommended that you create a new client for each atomic
-    operation you perform.
+        user_agent = f"{self.user_agent} PyGithub/python (app_id={self.app_id}"
+        if installation_id:
+            user_agent += f", installation_id={installation_id})"
+        return user_agent
 
-    This requires you to install `PyGithub`.
-    """
+    @property
+    def jwt(self) -> TokenInfo:
+        """
+        Returns the JWT for your GitHub application. The JWT is the token to use with GitHub application APIs.
+        """
 
-    if isinstance(settings, dict):
-      settings = GithubClientSettings(**settings)
-    elif settings is None:
-      settings = GithubClientSettings()
+        return self._jwt_supplier()
 
-    settings = self._get_base_github_client_settings().update(settings)
-    return settings.make_client(jwt=self.jwt.value)
+    @property
+    def jwt_supplier(self) -> JwtSupplier:
+        """
+        Returns a new #JwtSupplier that is used for generating JWT tokens for your GitHub application.
+        """
 
-  def __requestor(self, auth_header: str, installation_id: int) -> t.Dict[str, str]:
-    return requests.post(
-      self.v3_api_url.rstrip('/') + f'/app/installations/{installation_id}/access_tokens',
-      headers={'Authorization': auth_header, 'User-Agent': user_agent},
-    ).json()
+        return JwtSupplier(self.app_id, self.private_key)
 
-  def get_installation_token_supplier(self, installation_id: int) -> InstallationTokenSupplier:
-    """
-    Create an #InstallationTokenSupplier for your GitHub application to act within the scope of the given
-    *installation_id*.
-    """
+    def app_client(self, settings: t.Union[GithubClientSettings, t.Dict[str, t.Any], None] = None) -> "github.Github":
+        """
+        Returns a PyGithub client for your GitHub application.
 
-    with self._lock:
-      return self._installation_tokens.setdefault(
-        installation_id,
-        InstallationTokenSupplier(
-          self._jwt_supplier,
-          installation_id,
-          self.__requestor,
-        )
-      )
+        Note that the client's token will expire after 10 minutes and you will have to create a new client or update the
+        client's token with the value returned by #jwt. It is recommended that you create a new client for each atomic
+        operation you perform.
 
-  def installation_token(self, installation_id: int) -> TokenInfo:
-    """
-    A short-hand to retrieve a new installation token for the given *installation_id*.
-    """
+        This requires you to install `PyGithub>=1.58`.
+        """
 
-    return self.get_installation_token_supplier(installation_id)()
+        if isinstance(settings, dict):
+            settings = GithubClientSettings(**settings)
+        elif settings is None:
+            settings = GithubClientSettings()
 
-  def installation_client(
-    self,
-    installation_id: int,
-    settings: t.Union[GithubClientSettings, t.Dict[str, t.Any], None] = None,
-  ) -> 'github.Github':
-    """
-    Returns a PyGithub client for your GitHub application to act in the scope of the given *installation_id*.
+        settings = self._get_base_github_client_settings().update(settings)
+        return settings.make_client(jwt=self.jwt.value)
 
-    Note that the client's token will expire after 10 minutes and you will have to create a new client or update the
-    client's token with the value returned by #jwt. It is recommended that you create a new client for each atomic
-    operation you perform.
+    def __requestor(self, auth_header: str, installation_id: int) -> t.Dict[str, str]:
+        return requests.post(
+            self.v3_api_url.rstrip("/") + f"/app/installations/{installation_id}/access_tokens",
+            headers={"Authorization": auth_header, "User-Agent": user_agent},
+        ).json()
 
-    This requires you to install `PyGithub`.
-    """
+    def get_installation_token_supplier(self, installation_id: int) -> InstallationTokenSupplier:
+        """
+        Create an #InstallationTokenSupplier for your GitHub application to act within the scope of the given
+        *installation_id*.
+        """
+
+        with self._lock:
+            return self._installation_tokens.setdefault(
+                installation_id,
+                InstallationTokenSupplier(
+                    self._jwt_supplier,
+                    installation_id,
+                    self.__requestor,
+                ),
+            )
+
+    def installation_token(self, installation_id: int) -> TokenInfo:
+        """
+        A short-hand to retrieve a new installation token for the given *installation_id*.
+        """
 
-    if isinstance(settings, dict):
-      settings = GithubClientSettings(**settings)
-    elif settings is None:
-      settings = GithubClientSettings()
+        return self.get_installation_token_supplier(installation_id)()
 
-    token = self.installation_token(installation_id).value
-    settings = self._get_base_github_client_settings().update(settings)
-    return settings.make_client(login_or_token=token)
+    def installation_client(
+        self,
+        installation_id: int,
+        settings: t.Union[GithubClientSettings, t.Dict[str, t.Any], None] = None,
+    ) -> "github.Github":
+        """
+        Returns a PyGithub client for your GitHub application to act in the scope of the given *installation_id*.
+
+        Note that the client's token will expire after 10 minutes and you will have to create a new client or update the
+        client's token with the value returned by #jwt. It is recommended that you create a new client for each atomic
+        operation you perform.
+
+        This requires you to install `PyGithub>=1.58`.
+        """
+
+        if isinstance(settings, dict):
+            settings = GithubClientSettings(**settings)
+        elif settings is None:
+            settings = GithubClientSettings()
+
+        token = self.installation_token(installation_id).value
+        settings = self._get_base_github_client_settings().update(settings)
+        return settings.make_client(login_or_token=token)

github_bot_api/app_test.py

@@ -0,0 +1,16 @@
+from unittest.mock import patch
+
+from github_bot_api.app import GithubApp
+from github_bot_api.token import TokenInfo
+
+
+def test_simple_app():
+    """
+    Regression test for PyGithub 1.58+ where such code failed on:
+
+        AttributeError: module 'github.MainClass' has no attribute 'DEFAULT_TIMEOUT'
+    """
+    token = TokenInfo(1, "Bearer", "token")
+    with patch("github_bot_api.token.InstallationTokenSupplier._new_token", return_value=token):
+        app = GithubApp("UA/0.0.0", 42, "private_key")
+        app.installation_client(1)

github_bot_api/event.py

@@ -1,14 +1,14 @@
-
 """
 Abstraction of a GitHub Webhook event.
 
 Reference: https://docs.github.com/en/free-pro-team@latest/developers/webhooks-and-events/webhook-events-and-payloads
 """
 
-import logging
 import json
+import logging
 import typing as t
 from dataclasses import dataclass
+
 from .signature import check_signature
 from .utils.mime import get_mime_components
 
@@ -17,79 +17,79 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class Event:
-  """
-  Represents a GitHub webhook event.
-  """
+    """
+    Represents a GitHub webhook event.
+    """
 
-  #: The name of the event. Could be `pull_request`, for example.
-  name: str
+    name: str
+    """ The name of the event. Could be `pull_request`, for example."""
 
-  #: The delivery ID of the event.
-  delivery_id: str
+    delivery_id: str
+    """The delivery ID of the event."""
 
-  #: The signature of the event. Will only be set if a Webhook-secret is configured on the
-  #: client side (e.g. in #Webhook.secret / if the *webhook_secret* parameter is passed to
-  #: #accept_event()).
-  signature: t.Optional[str]
+    signature: t.Optional[str]
+    """The signature of the event. Will only be set if a Webhook-secret is configured on the
+    client side (e.g. in [`Webhook.secret`][github_bot_api.webhook.Webhook] / if the *webhook_secret* parameter is
+    passed to [`accept_event()`][github_bot_api.event.accept_event])."""
 
-  #: The user agent invoking the webhook.
-  user_agent: str
+    user_agent: str
+    """The user agent invoking the webhook."""
 
-  #: The event payload.
-  payload: t.Dict[str, t.Any]
+    payload: t.Dict[str, t.Any]
+    """The event payload."""
 
 
 def accept_event(
-  headers: t.Mapping[str, str],
-  raw_body: bytes,
-  webhook_secret: t.Optional[str] = None,
+    headers: t.Mapping[str, str],
+    raw_body: bytes,
+    webhook_secret: t.Optional[str] = None,
 ) -> Event:
-  """
-  Converts thee HTTP *headers* and the *raw_body* to an #Event object.
-
-  # Arguments
-  headers: The HTTP headers. Must have `X-Github-Event`, `X-Github-Delivery`, `User-Agent`, `Content-Type`.
-    May have `X-Hub-Signature` or `X-Hub-Signature-256`.
-  raw_body: The raw request body for the event. This is converted into a JSON payload.
-  webhook_secret: If specified, the `X-Hub-Signature` or `X-Hub-Signature-256` headers are used to verify
-    the signature of the payload. If not specified, the client does not validate the signature.
-  """
-
-  event_name = headers.get('X-GitHub-Event')
-  delivery_id = headers.get('X-GitHub-Delivery')
-  signature_1 = headers.get('X-Hub-Signature')
-  signature_256 = headers.get('X-Hub-Signature-256')
-  user_agent = headers.get('User-Agent')
-  content_type = headers.get('Content-Type')
-
-  if not event_name or not delivery_id or not user_agent or not content_type:
-    raise InvalidRequest('missing required headers')
-  if webhook_secret is not None and not (signature_1 or signature_256):
-    raise InvalidRequest('webhook secret is configured but no signature header was received')
-
-  mime_type, parameters = get_mime_components(content_type)
-  if mime_type != 'application/json':
-    raise InvalidRequest(f'expected Content-Type: application/json, got {content_type}')
-  encoding = dict(parameters).get('encoding', 'UTF-8')
-
-  if webhook_secret is not None:
-    if signature_256:
-      check_signature(signature_256, raw_body, webhook_secret.encode('ascii'), algo='sha256')
-    elif signature_1:
-      check_signature(signature_1, raw_body, webhook_secret.encode('ascii'), algo='sha1')
-    else:
-      raise RuntimeError
-
-  return Event(
-    event_name,
-    delivery_id,
-    signature_256 or signature_1,
-    user_agent,
-    json.loads(raw_body.decode(encoding)),
-  )
+    """
+    Converts thee HTTP *headers* and the *raw_body* to an #Event object.
+
+    Args:
+        headers: The HTTP headers. Must have `X-Github-Event`, `X-Github-Delivery`, `User-Agent`, `Content-Type`.
+                 May have `X-Hub-Signature` or `X-Hub-Signature-256`.
+        raw_body: The raw request body for the event. This is converted into a JSON payload.
+        webhook_secret: If specified, the `X-Hub-Signature` or `X-Hub-Signature-256` headers are used to verify
+                        the signature of the payload. If not specified, the client does not validate the signature.
+    """
+
+    event_name = headers.get("X-GitHub-Event")
+    delivery_id = headers.get("X-GitHub-Delivery")
+    signature_1 = headers.get("X-Hub-Signature")
+    signature_256 = headers.get("X-Hub-Signature-256")
+    user_agent = headers.get("User-Agent")
+    content_type = headers.get("Content-Type")
+
+    if not event_name or not delivery_id or not user_agent or not content_type:
+        raise InvalidRequest("missing required headers")
+    if webhook_secret is not None and not signature_1 and not signature_256:
+        raise InvalidRequest("webhook secret is configured but no signature header was received")
+
+    mime_type, parameters = get_mime_components(content_type)
+    if mime_type != "application/json":
+        raise InvalidRequest(f"expected Content-Type: application/json, got {content_type}")
+    encoding = dict(parameters).get("encoding", "UTF-8")
+
+    if webhook_secret is not None:
+        if signature_256:
+            check_signature(signature_256, raw_body, webhook_secret.encode("ascii"), algo="sha256")
+        elif signature_1:
+            check_signature(signature_1, raw_body, webhook_secret.encode("ascii"), algo="sha1")
+        else:
+            raise RuntimeError
+
+    return Event(
+        event_name,
+        delivery_id,
+        signature_256 or signature_1,
+        user_agent,
+        json.loads(raw_body.decode(encoding)),
+    )
 
 
 class InvalidRequest(Exception):
-  """
-  Raised when an invalid request is passed to #accept_event().
-  """
+    """
+    Raised when an invalid request is passed to #accept_event().
+    """

github_bot_api/flask.py

@@ -1,4 +1,3 @@
-
 """
 Flask binding for handling GitHub webhook events.
 
@@ -23,38 +22,40 @@ flask_app.run()
 ```
 """
 
-import flask
 import typing as t
+
+import flask
+
 from .event import accept_event
 from .webhook import Webhook
 
 
 def create_event_handler(webhook: Webhook) -> t.Callable[[], t.Tuple[t.Text, int, t.Dict[str, str]]]:
-  """
-  Creates an event handler flask view that interprets the received HTTP request as a GitHub application
-  event and dispatches it via #webhook.dispatch().
-  """
+    """
+    Creates an event handler flask view that interprets the received HTTP request as a GitHub application
+    event and dispatches it via #webhook.dispatch().
+    """
+
+    def event_handler():
+        event = accept_event(
+            t.cast(t.Mapping[str, str], flask.request.headers), flask.request.get_data(), webhook.secret
+        )
+        webhook.dispatch(event)
+        return "", 202, {}
 
-  def event_handler():
-    event = accept_event(
-      t.cast(t.Mapping[str, str], flask.request.headers),
-      flask.request.get_data(),
-      webhook.secret)
-    webhook.dispatch(event)
-    return '', 202, {}
-  return event_handler
+    return event_handler
 
 
 def create_flask_app(
-  name: str,
-  webhook: Webhook,
-  path: str = '/event-handler',
+    name: str,
+    webhook: Webhook,
+    path: str = "/event-handler",
 ) -> flask.Flask:
-  """
-  Creates a new #flask.Flask application with a `POST` event handler under the given *path* (defaulting
-  to `/event-handler`). This is a useful shorthand to attach your #Webhook to an HTTP server.
-  """
-
-  flask_app = flask.Flask(name)
-  flask_app.route(path, methods=['POST'])(create_event_handler(webhook))
-  return flask_app
+    """
+    Creates a new #flask.Flask application with a `POST` event handler under the given *path* (defaulting
+    to `/event-handler`). This is a useful shorthand to attach your #Webhook to an HTTP server.
+    """
+
+    flask_app = flask.Flask(name)
+    flask_app.route(path, methods=["POST"])(create_event_handler(webhook))
+    return flask_app