flask-githubkit 0.1.2__py3-none-any.whl

flask_githubkit/__init__.py

@@ -0,0 +1,11 @@
+"""Flask extension for GitHub OAuth login, built on GitHubKit."""
+
+import flask_githubkit.auth
+import flask_githubkit.config
+import flask_githubkit.store
+
+GitHub = flask_githubkit.auth.GitHub
+Config = flask_githubkit.config.Config
+Token = flask_githubkit.store.Token
+
+__all__ = ["Config", "GitHub", "Token"]

flask_githubkit/auth.py

@@ -0,0 +1,233 @@
+"""GitHub OAuth web flow for Flask, backed by GitHubKit."""
+
+import collections.abc
+import functools
+import typing
+import urllib.parse
+
+import flask
+import githubkit
+import githubkit.auth
+import githubkit.exception
+import httpx
+import werkzeug.routing
+import werkzeug.wrappers
+
+import flask_githubkit.config
+import flask_githubkit.store
+
+AUTHORIZE_URL = "https://github.com/login/oauth/authorize"
+CLIENT_ATTR = "flask_githubkit_client"
+LOGIN_VIEW = "login"
+LOGIN_MARK = "_flask_githubkit_login"
+
+ViewResult = (
+    werkzeug.wrappers.Response | tuple[werkzeug.wrappers.Response, int]
+)
+
+
+class GitHub:
+    """GitHub OAuth web flow for Flask, backed by GitHubKit.
+
+    ``login`` starts the flow and ``callback`` wraps the callback view,
+    passing it the access token (or ``None`` if the user denied
+    access). ``client`` returns one GitHub client per request for the
+    signed-in user. ``init_app`` sends users to the endpoint named by
+    ``GITHUB_LOGIN_VIEW`` (default ``login``) when their refresh token
+    has expired.
+
+    ``scope`` and ``login_view`` may be given here. When they are not,
+    they come from ``GITHUB_SCOPE`` and ``GITHUB_LOGIN_VIEW`` in the
+    Flask config. The scope then defaults to ``read:user``. The login
+    view defaults to the view decorated with ``@login``, or to
+    ``login`` if there is none. Tokens are kept by ``store.Token`` in
+    ``flask.session``.
+    """
+
+    def __init__(
+        self,
+        app: flask.Flask | None = None,
+        *,
+        scope: str | None = None,
+        login_view: str | None = None,
+    ) -> None:
+        self.scope = scope
+        self.login_view = login_view
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: flask.Flask) -> None:
+        app.register_error_handler(
+            githubkit.exception.AuthExpiredError, self._expired
+        )
+
+    @typing.overload
+    def login(self) -> ViewResult: ...
+
+    @typing.overload
+    def login(
+        self, view_func: collections.abc.Callable[..., typing.Any]
+    ) -> collections.abc.Callable[..., ViewResult]: ...
+
+    def login(
+        self,
+        view_func: collections.abc.Callable[..., typing.Any] | None = None,
+    ) -> ViewResult | collections.abc.Callable[..., ViewResult]:
+        """Start the OAuth flow.
+
+        Call ``login()`` inside a view, or use ``@github.login`` as a
+        decorator. The decorated function is replaced by one that
+        redirects to GitHub, and keeps its name for ``url_for``.
+        """
+        if view_func is None:
+            return self._redirect()
+
+        @functools.wraps(view_func)
+        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> ViewResult:
+            return self._redirect()
+
+        setattr(wrapper, LOGIN_MARK, self)
+        return wrapper
+
+    def _redirect(self) -> ViewResult:
+        config = self._config()
+        if config is None:
+            return self._error("GitHub OAuth is not configured.", 500)
+        return flask.redirect(self._url(config))
+
+    def callback(
+        self, view_func: collections.abc.Callable[..., ViewResult]
+    ) -> collections.abc.Callable[..., ViewResult]:
+        @functools.wraps(view_func)
+        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> ViewResult:
+            if not self._check_state():
+                return self._error("Invalid OAuth state.", 400)
+
+            if flask.request.args.get("error"):
+                return view_func(None, *args, **kwargs)
+
+            code = flask.request.args.get("code")
+            if not code:
+                return self._error(
+                    "GitHub did not return an authorization code.", 400
+                )
+
+            config = self._config()
+            if config is None:
+                return self._error("GitHub OAuth is not configured.", 500)
+
+            try:
+                strategy = self._exchange(code, config)
+            except (githubkit.exception.RequestError, httpx.HTTPError):
+                return self._error("Could not reach GitHub.", 502)
+            flask_githubkit.store.Token.save(strategy)
+            return view_func(strategy.token, *args, **kwargs)
+
+        return wrapper
+
+    def client(self) -> "githubkit.GitHub[typing.Any] | None":
+        """Return the request's GitHub client, or None if signed out.
+
+        The client is created once per request, so a token refresh
+        happens once and every caller sees the new token. GitHubKit
+        refreshes an expired access token itself; the refreshed values
+        are saved to the session at the end of the request.
+        """
+        clients: dict[GitHub, githubkit.GitHub[typing.Any]] | None = getattr(
+            flask.g, CLIENT_ATTR, None
+        )
+        if clients is None:
+            clients = {}
+            setattr(flask.g, CLIENT_ATTR, clients)
+
+        cached = clients.get(self)
+        if cached is not None:
+            return cached
+
+        config = self._config()
+        if config is None:
+            return None
+        strategy = flask_githubkit.store.Token.load(config)
+        if strategy is None:
+            return None
+
+        def _save(
+            response: werkzeug.wrappers.Response,
+        ) -> werkzeug.wrappers.Response:
+            if flask_githubkit.store.Token.exists():
+                flask_githubkit.store.Token.save(strategy)
+            return response
+
+        flask.after_this_request(_save)
+        github = githubkit.GitHub(auth=strategy)
+        clients[self] = github
+        return github
+
+    def logout(self) -> None:
+        flask_githubkit.store.Token.clear()
+        flask.g.pop(CLIENT_ATTR, None)
+
+    @staticmethod
+    def _config() -> flask_githubkit.config.Config | None:
+        return flask_githubkit.config.Config.from_current_app()
+
+    def _url(self, config: flask_githubkit.config.Config) -> str:
+        query = urllib.parse.urlencode(
+            {
+                "client_id": config.client_id,
+                "redirect_uri": config.redirect_uri,
+                "scope": self.scope or config.scope,
+                "state": flask_githubkit.store.State.new(),
+            }
+        )
+        return f"{AUTHORIZE_URL}?{query}"
+
+    @staticmethod
+    def _check_state() -> bool:
+        received = flask.request.args.get("state", "")
+        return flask_githubkit.store.State.check(received)
+
+    @staticmethod
+    def _exchange(
+        code: str,
+        config: flask_githubkit.config.Config,
+    ) -> githubkit.auth.OAuthTokenAuthStrategy:
+        app = githubkit.auth.OAuthAppAuthStrategy(
+            client_id=config.client_id,
+            client_secret=config.client_secret,
+        )
+        return app.as_web_user(
+            code, redirect_uri=config.redirect_uri
+        ).exchange_token(githubkit.GitHub(auth=app))
+
+    def _expired(
+        self, error: githubkit.exception.AuthExpiredError
+    ) -> werkzeug.wrappers.Response:
+        self.logout()
+        view = (
+            self.login_view
+            or flask.current_app.config.get("GITHUB_LOGIN_VIEW")
+            or self._decorated_endpoint()
+            or LOGIN_VIEW
+        )
+        try:
+            return flask.redirect(flask.url_for(view))
+        except werkzeug.routing.BuildError as build_error:
+            raise RuntimeError(
+                f"GITHUB_LOGIN_VIEW {view!r} is not a Flask endpoint. "
+                "Use the endpoint name, such as 'auth.login' for a "
+                "blueprint named 'auth'."
+            ) from build_error
+
+    def _decorated_endpoint(self) -> str | None:
+        """Return the endpoint of the view decorated with ``@login``."""
+        for endpoint, view in flask.current_app.view_functions.items():
+            if getattr(view, LOGIN_MARK, None) is self:
+                return endpoint
+        return None
+
+    @staticmethod
+    def _error(
+        message: str, status: int
+    ) -> tuple[werkzeug.wrappers.Response, int]:
+        return flask.jsonify({"message": message}), status

flask_githubkit/config.py

@@ -0,0 +1,47 @@
+"""OAuth App settings read from the Flask application config."""
+
+import dataclasses
+
+import flask
+
+SCOPE = "read:user"
+
+
+@dataclasses.dataclass(frozen=True)
+class Config:
+    """OAuth App settings read from the Flask app config.
+
+    Reads ``GITHUB_CLIENT_ID``, ``GITHUB_CLIENT_SECRET`` and
+    ``GITHUB_REDIRECT_URI``. ``SECRET_KEY`` must also be set, because
+    the OAuth state and tokens are kept in ``flask.session``.
+    ``GITHUB_SCOPE`` is optional: the space-separated OAuth scope to
+    request, ``read:user`` by default.
+    """
+
+    client_id: str
+    client_secret: str
+    redirect_uri: str
+    scope: str = SCOPE
+
+    @staticmethod
+    def from_current_app() -> "Config | None":
+        app_config = flask.current_app.config
+        client_id = app_config.get("GITHUB_CLIENT_ID")
+        client_secret = app_config.get("GITHUB_CLIENT_SECRET")
+        redirect_uri = app_config.get("GITHUB_REDIRECT_URI")
+        scope = app_config.get("GITHUB_SCOPE", SCOPE)
+        secret_key = app_config.get("SECRET_KEY")
+        if not all(
+            isinstance(value, str) and value
+            for value in (
+                client_id,
+                client_secret,
+                redirect_uri,
+                scope,
+                secret_key,
+            )
+        ):
+            return None
+        return Config(
+            str(client_id), str(client_secret), str(redirect_uri), str(scope)
+        )

flask_githubkit/store.py

@@ -0,0 +1,92 @@
+"""Everything flask_githubkit keeps in the Flask session."""
+
+import datetime
+import hmac
+import secrets
+
+import flask
+import githubkit.auth
+import githubkit.exception
+
+import flask_githubkit.config
+
+TOKEN_KEY = "flask_githubkit.token"
+STATE_KEY = "flask_githubkit.state"
+DATETIME_KEYS = ("expire_time", "refresh_token_expire_time")
+
+
+class Token:
+    """Keeps a user's GitHub tokens in ``flask.session``.
+
+    With a server-side session backend such as Redis, the browser only
+    holds the session id. Sessions are marked permanent, so
+    ``PERMANENT_SESSION_LIFETIME`` is their expiry and each save resets
+    it.
+    """
+
+    @staticmethod
+    def save(strategy: githubkit.auth.OAuthTokenAuthStrategy) -> None:
+        payload: dict[str, str | None] = {
+            "token": strategy.token,
+            "refresh_token": strategy.refresh_token,
+        }
+        for key in DATETIME_KEYS:
+            value = getattr(strategy, key)
+            payload[key] = value.isoformat() if value else None
+
+        flask.session.permanent = True
+        flask.session[TOKEN_KEY] = payload
+
+    @staticmethod
+    def load(
+        config: flask_githubkit.config.Config,
+    ) -> githubkit.auth.OAuthTokenAuthStrategy | None:
+        payload = flask.session.get(TOKEN_KEY)
+        if not isinstance(payload, dict):
+            return None
+
+        try:
+            return githubkit.auth.OAuthTokenAuthStrategy(
+                client_id=config.client_id,
+                client_secret=config.client_secret,
+                token=payload.get("token"),
+                refresh_token=payload.get("refresh_token"),
+                **{
+                    key: datetime.datetime.fromisoformat(payload[key])
+                    if payload.get(key)
+                    else None
+                    for key in DATETIME_KEYS
+                },
+            )
+        except (
+            githubkit.exception.AuthCredentialError,
+            TypeError,
+            ValueError,
+        ):
+            Token.clear()
+            return None
+
+    @staticmethod
+    def clear() -> None:
+        flask.session.pop(TOKEN_KEY, None)
+
+    @staticmethod
+    def exists() -> bool:
+        return TOKEN_KEY in flask.session
+
+
+class State:
+    """Keeps the one-time OAuth ``state`` value in ``flask.session``."""
+
+    @staticmethod
+    def new() -> str:
+        state = secrets.token_urlsafe(32)
+        flask.session[STATE_KEY] = state
+        return state
+
+    @staticmethod
+    def check(received: str) -> bool:
+        expected = flask.session.pop(STATE_KEY, None)
+        return isinstance(expected, str) and hmac.compare_digest(
+            expected, received
+        )

flask_githubkit-0.1.2.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: flask-githubkit
+Version: 0.1.2
+Summary: Flask extension for GitHub OAuth login, built on GitHubKit. Handles expiring-token refresh and server-side sessions.
+Author: LJFCoding
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/LJFCoding/flask-githubkit
+Project-URL: Repository, https://github.com/LJFCoding/flask-githubkit
+Project-URL: Issues, https://github.com/LJFCoding/flask-githubkit/issues
+Keywords: flask,github,githubkit,oauth,authentication
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Session
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask>=3.0
+Requires-Dist: githubkit<1.0,>=0.16.1
+Requires-Dist: httpx<1.0,>=0.23
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
+Dynamic: license-file
+
+# flask-githubkit
+
+A Flask extension for GitHub OAuth login, built on
+[GitHubKit](https://github.com/yanyongyu/githubkit). It handles expiring-token
+refresh and stores tokens in `flask.session`.
+
+## Installation
+
+Install the release directly from GitHub:
+
+```console
+pip install "flask-githubkit @ git+https://github.com/LJFCoding/flask-githubkit.git@v0.1.2"
+```
+
+It is not published on PyPI yet, so `pip install flask-githubkit` will not
+find it. It requires Python 3.10+ and installs Flask, GitHubKit and httpx.
+
+For local development, install the test dependencies with
+`pip install -e ".[test]"`.
+
+## How it works
+
+1. `github.login()` redirects the user to GitHub with a random `state` value
+   that is kept in `flask.session`.
+2. GitHub redirects back to your callback URL with a `code` and the `state`.
+3. `@github.callback` checks the `state` (blocking login CSRF), exchanges the
+   `code` for tokens through GitHubKit, saves them in `flask.session`, and
+   calls your view with the access token.
+4. In any later request, `github.client()` returns a GitHubKit client for that
+   user. GitHubKit refreshes an expired access token itself, and the new
+   token values are saved back to the session when the request finishes.
+
+The names follow [Flask-GitHub](https://github.com/cenkalti/github-flask), but
+the API is smaller and the HTTP calls are made by
+[GitHubKit](https://github.com/yanyongyu/githubkit), so you get its typed
+`rest` methods instead of raw `get`/`post` helpers. Only synchronous Flask
+apps are supported.
+
+## Quick start
+
+Register a GitHub OAuth App and set its callback URL to the value of
+`GITHUB_REDIRECT_URI`. Enable **Expire user authorization tokens** in the
+OAuth App settings if you want GitHub to issue refresh tokens.
+
+```python
+import flask
+import flask_githubkit
+
+app = flask.Flask(__name__)
+app.config.update(
+    SECRET_KEY="load-this-from-a-secret-manager",
+    GITHUB_CLIENT_ID="your-client-id",
+    GITHUB_CLIENT_SECRET="load-this-from-a-secret-manager",
+    GITHUB_REDIRECT_URI="https://example.com/callback",
+    GITHUB_SCOPE="read:user",
+)
+
+github = flask_githubkit.GitHub(app)
+
+
+@app.route("/login")
+@github.login
+def login():
+    """Replaced by a redirect to GitHub."""
+
+
+@app.route("/callback")
+@github.callback
+def callback(access_token):
+    if access_token is None:
+        return flask.jsonify(
+            {"message": "GitHub authorization was denied"}
+        ), 401
+    return flask.jsonify({"message": "Signed in"})
+
+
+@app.route("/me")
+def me():
+    api = github.client()
+    if api is None:
+        return flask.redirect(flask.url_for("login"))
+    user = api.rest.users.get_authenticated().parsed_data
+    return flask.jsonify({"login": user.login})
+```
+
+`callback` validates the OAuth `state`, exchanges the authorization
+code, stores the token data, and calls the decorated view with the access token.
+If the user denies access, the view receives `None`. Protect callback handling
+with the decorator as shown; it is responsible for validating `state`.
+
+With an application factory, create the extension once and initialize it for
+each app:
+
+```python
+github = flask_githubkit.GitHub()
+
+
+def create_app():
+    app = flask.Flask(__name__)
+    app.config.from_mapping(
+        SECRET_KEY="load-this-from-a-secret-manager",
+        GITHUB_CLIENT_ID="your-client-id",
+        GITHUB_CLIENT_SECRET="load-this-from-a-secret-manager",
+        GITHUB_REDIRECT_URI="https://example.com/callback",
+        GITHUB_SCOPE="read:user",
+    )
+    github.init_app(app)
+    return app
+```
+
+## Examples
+
+Each file in [examples/](examples) is a complete app. They are checked by the
+test suite, which confirms the login route redirects to GitHub.
+
+| File | Shows |
+| --- | --- |
+| [single_file.py](examples/single_file.py) | A module-level app with `GitHub(app)` |
+| [factory.py](examples/factory.py) | An app factory with `init_app` and the optional config keys |
+| [blueprint.py](examples/blueprint.py) | Login routes in a blueprint; the `auth.login` endpoint is found from `@github.login` |
+| [routes.py](examples/routes.py) | A `login_required` decorator and a route that calls the GitHub API |
+
+Set `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET` and `SECRET_KEY` in your
+environment, then run one with, for example,
+`flask --app examples/single_file run`.
+
+Calling the API goes through GitHubKit, so see its
+[documentation](https://yanyongyu.github.io/githubkit/) for everything
+`client().rest` offers.
+
+## Coming from Flask-GitHub
+
+| Flask-GitHub | flask-githubkit |
+| --- | --- |
+| `GitHub(app)` | `GitHub(app)` or `init_app(app)` |
+| `github.authorize()` | `@github.login`, or `github.login()` in a view |
+| `@github.authorized_handler` | `@github.callback` |
+| `@github.access_token_getter` | Not needed: tokens are kept in `flask.session` |
+| `github.get("user")` | `github.client().rest.users.get_authenticated()` |
+| `authorize(scope=..., redirect_uri=...)` | Not supported: use `scope=` in `GitHub(...)` or `GITHUB_SCOPE`, and `GITHUB_REDIRECT_URI` |
+
+## Configuration and API
+
+| Flask config key | Required | Purpose |
+| --- | --- | --- |
+| `GITHUB_CLIENT_ID` | Yes | GitHub OAuth App client ID |
+| `GITHUB_CLIENT_SECRET` | Yes | GitHub OAuth App client secret |
+| `GITHUB_REDIRECT_URI` | Yes | Callback URL registered with the OAuth App |
+| `SECRET_KEY` | Yes | Flask session signing key |
+| `GITHUB_SCOPE` | No | Space-separated OAuth scopes to request. Default `read:user`. |
+| `GITHUB_LOGIN_VIEW` | No | Endpoint name users are sent to when their refresh token has expired. Usually not needed: see below. It is an endpoint name such as `auth.login`, not a URL. |
+
+`flask_githubkit.GitHub(app=None, *, scope=None, login_view=None)` accepts an
+optional Flask app. Use `init_app(app)` to initialize it later.
+
+`scope` and `login_view` are optional. Each one is taken from the constructor
+if you pass it, otherwise from `GITHUB_SCOPE` or `GITHUB_LOGIN_VIEW` in the
+Flask config. If neither is set, the scope is `read:user`. The login view is
+the view you decorated with `@github.login`, with its blueprint prefix
+(`auth.login`), or an endpoint named `login` if there is no decorated view.
+The client ID, client secret, redirect URI and `SECRET_KEY` always come from
+the Flask config.
+
+```python
+github = flask_githubkit.GitHub(
+    scope="read:user repo", login_view="auth.login"
+)
+```
+
+- `@github.login` turns a view into a redirect to GitHub that starts the
+  OAuth flow. You can also call `github.login()` inside a view and return
+  the result, which is useful if you want to run code first. The decorated
+  function's body never runs.
+- `@callback` wraps the callback view.
+- `client()` returns the request-cached GitHubKit `GitHub` client, or `None`
+  when there is no valid stored token.
+- `logout()` removes the stored GitHub token from the session.
+
+The extension registers an `AuthExpiredError` handler that clears the stored
+token and redirects to the login view. GitHubKit also raises
+`AuthExpiredError` when GitHub rejects the authorization code, so a stale or
+reused code sends the user back to login. If GitHub cannot be reached while
+exchanging the code (a timeout, a connection error or a 5xx response), the
+callback returns a `502` JSON error, `Could not reach GitHub.`, and does not
+call your view. If the login view is not a real
+endpoint, the handler raises a `RuntimeError` that says so.
+
+`flask_githubkit.Config.from_current_app()` reads the configuration keys above.
+`flask_githubkit.Token` serializes token expiry datetimes as ISO-formatted
+strings in `flask.session`.
+
+## Sessions, token refresh, and limitations
+
+The default Flask session is a signed, client-side cookie; it is **not
+encrypted**, so users can read its contents. This package stores OAuth token
+data there, so use a server-side session backend such as Flask-Session with
+Redis in production. The extension only uses `flask.session` and marks the
+session permanent when it saves tokens. Configure your backend and
+`PERMANENT_SESSION_LIFETIME` (for example, 30 days) in your application; sliding
+expiry and TTL behavior depend on that backend and are not provided by this
+package.
+
+GitHubKit refreshes expired access tokens when the client is used. The extension
+writes updated token values back to the session after the request. GitHub
+refresh tokens are single-use, so concurrent requests can race while refreshing;
+this package does not provide a distributed lock. Errors raised while your own
+code uses `client()` (for example a network failure during an API call) are not
+caught by the extension.
+
+This package supports synchronous Flask apps and GitHub OAuth Apps. It does not
+support GitHub Apps or configure GitHub Enterprise endpoints. Real GitHub code
+exchange and refresh, Redis operation, and Flask-Session TTL behavior require
+integration testing against those services and are not verified by the
+automated tests in this repository.
+
+## Tests
+
+```console
+pip install -e ".[test]"
+pytest
+```
+
+CI also requires 100% line and branch coverage:
+
+```console
+coverage run -m pytest
+coverage report
+```

flask_githubkit-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+flask_githubkit/__init__.py,sha256=AZt9expycUWgbxbKHIWtjnLHId-5ML13tepLQAeX3MU,308
+flask_githubkit/auth.py,sha256=fDO-oSCFEywqNQLh_w_11qHtvPwJlhjy2kXGc7iprkE,7919
+flask_githubkit/config.py,sha256=28OOjlIpBjHAMOsisu1sJcl7XRmkUesqAi9LAfrVgiQ,1414
+flask_githubkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_githubkit/store.py,sha256=2PzbYa8-dMD5_vHTZDjxb0jhClWRNVc3qVk84lbnHHw,2645
+flask_githubkit-0.1.2.dist-info/licenses/LICENSE,sha256=M7lCXlVXCyRAtQabbdCdtyn9PNxUSHCYi-fAz3jUmyI,1066
+flask_githubkit-0.1.2.dist-info/METADATA,sha256=demhXsk-LceMVsl2ayaNpKi3ZJfCNUQpJs2rLUt7yyE,10269
+flask_githubkit-0.1.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+flask_githubkit-0.1.2.dist-info/top_level.txt,sha256=lDJ7tJYO7dwMWR59OaihDiG7Hm3WG4MYYUiko-aeHS8,16
+flask_githubkit-0.1.2.dist-info/RECORD,,

flask_githubkit-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flask_githubkit-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LJFCoding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flask_githubkit-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+flask_githubkit