githubkit 0.11.0a0__py3-none-any.whl → 0.11.0a2__py3-none-any.whl

githubkit/__init__.py

@@ -1,8 +1,13 @@
+from . import lazy_module
+
+lazy_module.apply()
+
 from .config import Config as Config
 from .github import GitHub as GitHub
 from .core import GitHubCore as GitHubCore
 from .response import Response as Response
 from .paginator import Paginator as Paginator
+from .compat import GitHubModel as GitHubModel
 from .auth import AppAuthStrategy as AppAuthStrategy
 from .auth import BaseAuthStrategy as BaseAuthStrategy
 from .auth import TokenAuthStrategy as TokenAuthStrategy

githubkit/auth/_url.py

@@ -26,21 +26,38 @@ APP_ROUTES = {
 }
 
 BYPASS_REGEX = re.compile(r"/login/(oauth/access_token|device/code)$")
-APP_AUTH_REGEX = re.compile(rf"(?:{'|'.join(APP_ROUTES)})[^/]*$", re.I)
+"""Regex to match routes that should bypass auth.
+
+See: https://github.com/octokit/auth-oauth-user.js/blob/b8b1141b21f285027e36a4a1670163e4db51d30f/src/hook.ts#L44
+"""
+APP_AUTH_REGEX = re.compile(rf"^(?:{'|'.join(APP_ROUTES)})$", re.I)
+"""Regex to match app authentication routes.
+
+See: https://github.com/octokit/auth-app.js/blob/c0068e06081a5d930799285a7c79c9c948b676b6/src/requires-app-auth.ts#L45
+"""
 BASIC_AUTH_REGEX = re.compile(r"/applications/[^/]+/(token|grant)s?")
+"""Regex to match basic authentication routes.
+
+See: https://github.com/octokit/auth-oauth-user.js/blob/b8b1141b21f285027e36a4a1670163e4db51d30f/src/requires-basic-auth.ts#L17
+"""
 OAUTH_BASE_REGEX = re.compile(r"^https://(api\.)?github\.com/?$")
 
 
 def require_bypass(url: httpx.URL) -> bool:
-    # bypass oauth web flow and device flow
+    """Check if the request should bypass auth."""
     return bool(BYPASS_REGEX.search(url.path))
 
 
 def require_app_auth(url: httpx.URL) -> bool:
+    """Check if the request should use app authentication.
+
+    Note: the input url must remove the base url first.
+    """
     return bool(APP_AUTH_REGEX.search(url.path))
 
 
 def require_basic_auth(url: httpx.URL) -> bool:
+    """Check if the request should use basic authentication."""
     return bool(BASIC_AUTH_REGEX.search(url.path))
 
 

githubkit/auth/app.py

@@ -7,12 +7,7 @@ import httpx
 from githubkit.exception import AuthCredentialError
 from githubkit.cache import DEFAULT_CACHE, BaseCache
 from githubkit.utils import UNSET, Unset, exclude_unset
-from githubkit.rest import (
-    BasicError,
-    ValidationError,
-    InstallationToken,
-    AppInstallationsInstallationIdAccessTokensPostBody,
-)
+from githubkit.compat import model_dump, type_validate_python
 
 from .base import BaseAuthStrategy
 from .oauth import OAuthAppAuthStrategy
@@ -25,7 +20,8 @@ except ImportError:
 
 if TYPE_CHECKING:
     from githubkit import Response, GitHubCore
-    from githubkit.rest.types import AppPermissionsType
+    from githubkit.versions.latest.models import InstallationToken
+    from githubkit.versions.latest.types import AppPermissionsType
 
 
 @dataclass
@@ -49,6 +45,16 @@ class AppAuth(httpx.Auth):
         "{installation_id}:{permissions}:{repositories}:{repository_ids}"
     )
 
+    def _get_api_route(self, url: httpx.URL) -> httpx.URL:
+        """Get the api route (path only) for the given url."""
+        base_url_path = self.github.config.base_url.path
+        if (path := url.path).startswith(base_url_path):
+            path = path[len(base_url_path) :]
+            # add leading slash
+            if not path.startswith("/"):
+                path = "/" + path
+        return httpx.URL(path=path)
+
     def _create_jwt(self) -> str:
         """Create a JWT authenticating as GitHub APP.
 
@@ -80,6 +86,10 @@ class AppAuth(httpx.Auth):
         return token
 
     def _build_installation_auth_request(self) -> httpx.Request:
+        from githubkit.versions.latest.models import (
+            AppInstallationsInstallationIdAccessTokensPostBody,
+        )
+
         if self.installation_id is UNSET:
             raise AuthCredentialError(
                 "GitHub APP installation_id must be provided "
@@ -91,13 +101,16 @@ class AppAuth(httpx.Auth):
             raw_path=base_url.raw_path
             + f"app/installations/{self.installation_id}/access_tokens".encode("ascii")
         )
-        body = AppInstallationsInstallationIdAccessTokensPostBody.model_validate(
-            {
-                "repositories": self.repositories,
-                "repository_ids": self.repository_ids,
-                "permissions": self.permissions,
-            }
-        ).model_dump(by_alias=True)
+        body = model_dump(
+            type_validate_python(
+                AppInstallationsInstallationIdAccessTokensPostBody,
+                {
+                    "repositories": self.repositories,
+                    "repository_ids": self.repository_ids,
+                    "permissions": self.permissions,
+                },
+            )
+        )
         return httpx.Request(
             "POST",
             url,
@@ -111,6 +124,12 @@ class AppAuth(httpx.Auth):
     def _parse_installation_auth_response(
         self, response: httpx.Response
     ) -> "Response[InstallationToken]":
+        from githubkit.versions.latest.models import (
+            BasicError,
+            ValidationError,
+            InstallationToken,
+        )
+
         return self.github._check(
             response,
             response_model=InstallationToken,
@@ -150,7 +169,7 @@ class AppAuth(httpx.Auth):
         if require_bypass(request.url):
             yield request
             return
-        if require_app_auth(request.url):
+        if require_app_auth(self._get_api_route(request.url)):
             request.headers["Authorization"] = f"Bearer {self.get_jwt()}"
             yield request
             return
@@ -186,7 +205,7 @@ class AppAuth(httpx.Auth):
         if require_bypass(request.url):
             yield request
             return
-        if require_app_auth(request.url):
+        if require_app_auth(self._get_api_route(request.url)):
             request.headers["Authorization"] = f"Bearer {await self.aget_jwt()}"
             yield request
             return

githubkit/compat.py

@@ -0,0 +1,110 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Type,
+    TypeVar,
+    Callable,
+    Protocol,
+    Generator,
+)
+
+from pydantic import VERSION
+
+T = TypeVar("T")
+
+PYDANTIC_V2 = int(VERSION.split(".", 1)[0]) == 2
+
+if TYPE_CHECKING:
+
+    class ModelBeforeValidator(Protocol):
+        def __call__(self, cls: Any, __value: Any) -> Any:
+            ...
+
+    class CustomValidationClass(Protocol):
+        @classmethod
+        def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]:
+            ...
+
+    CVC = TypeVar("CVC", bound=CustomValidationClass)
+
+
+if PYDANTIC_V2:
+    from pydantic_core import CoreSchema, core_schema
+    from pydantic import (
+        BaseModel,
+        ConfigDict,
+        TypeAdapter,
+        GetCoreSchemaHandler,
+        model_validator,
+    )
+
+    class GitHubModel(BaseModel):
+        model_config = ConfigDict(populate_by_name=True)
+
+    class ExtraGitHubModel(GitHubModel):
+        model_config = ConfigDict(extra="allow")
+
+    def type_validate_python(type_: Type[T], data: Any) -> T:
+        return TypeAdapter(type_).validate_python(data)
+
+    def type_validate_json(type_: Type[T], data: Any) -> T:
+        return TypeAdapter(type_).validate_json(data)
+
+    def model_dump(model: BaseModel, by_alias: bool = True) -> Dict[str, Any]:
+        return model.model_dump(by_alias=by_alias)
+
+    def model_rebuild(model: Type[BaseModel]):
+        model.model_rebuild()
+
+    def model_before_validator(func: "ModelBeforeValidator"):
+        return model_validator(mode="before")(func)
+
+    def __get_pydantic_core_schema__(
+        cls: Type["CustomValidationClass"],
+        source_type: Any,
+        handler: GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        validators = list(cls.__get_validators__())
+        if len(validators) == 1:
+            return core_schema.no_info_plain_validator_function(validators[0])
+        return core_schema.chain_schema(
+            [core_schema.no_info_plain_validator_function(func) for func in validators]
+        )
+
+    def custom_validation(class_: Type["CVC"]) -> Type["CVC"]:
+        setattr(
+            class_,
+            "__get_pydantic_core_schema__",
+            classmethod(__get_pydantic_core_schema__),
+        )
+        return class_
+
+else:
+    from pydantic import Extra, BaseModel, parse_obj_as, parse_raw_as, root_validator
+
+    class GitHubModel(BaseModel):
+        class Config:
+            allow_population_by_field_name = True
+
+    class ExtraGitHubModel(BaseModel):
+        class Config:
+            extra = Extra.allow
+
+    def type_validate_python(type_: Type[T], data: Any) -> T:
+        return parse_obj_as(type_, data)
+
+    def type_validate_json(type_: Type[T], data: Any) -> T:
+        return parse_raw_as(type_, data)
+
+    def model_dump(model: BaseModel, by_alias: bool = True) -> Dict[str, Any]:
+        return model.dict(by_alias=by_alias)
+
+    def model_rebuild(model: Type[BaseModel]):
+        return model.update_forward_refs()
+
+    def model_before_validator(func: "ModelBeforeValidator"):
+        return root_validator(pre=True)(func)
+
+    def custom_validation(class_: Type["CVC"]) -> Type["CVC"]:
+        return class_

githubkit/config.py

@@ -12,6 +12,7 @@ class Config:
     user_agent: str
     follow_redirects: bool
     timeout: httpx.Timeout
+    http_cache: bool
 
     def dict(self) -> Dict[str, Any]:
         return asdict(self)
@@ -22,7 +23,11 @@ class Config:
 
 def build_base_url(base_url: Optional[Union[str, httpx.URL]]) -> httpx.URL:
     base_url = base_url or httpx.URL("https://api.github.com/")
-    return base_url if isinstance(base_url, httpx.URL) else httpx.URL(base_url)
+    base_url = base_url if isinstance(base_url, httpx.URL) else httpx.URL(base_url)
+    # enforce trailing slash
+    if not base_url.raw_path.endswith(b"/"):
+        base_url = base_url.copy_with(raw_path=base_url.raw_path + b"/")
+    return base_url
 
 
 def build_accept(
@@ -61,6 +66,7 @@ def get_config(
     user_agent: Optional[str] = None,
     follow_redirects: bool = True,
     timeout: Optional[Union[float, httpx.Timeout]] = None,
+    http_cache: bool = True,
 ) -> Config:
     return Config(
         build_base_url(base_url),
@@ -68,4 +74,5 @@ def get_config(
         build_user_agent(user_agent),
         follow_redirects,
         build_timeout(timeout),
+        http_cache,
     )

githubkit/core.py

@@ -17,6 +17,7 @@ from typing import (
 )
 
 import httpx
+import hishel
 
 from .response import Response
 from .utils import obj_to_jsonable
@@ -79,6 +80,7 @@ class GitHubCore(Generic[A]):
         user_agent: Optional[str] = None,
         follow_redirects: bool = True,
         timeout: Optional[Union[float, httpx.Timeout]] = None,
+        http_cache: bool = True,
     ):
         ...
 
@@ -94,6 +96,7 @@ class GitHubCore(Generic[A]):
         user_agent: Optional[str] = None,
         follow_redirects: bool = True,
         timeout: Optional[Union[float, httpx.Timeout]] = None,
+        http_cache: bool = True,
     ):
         ...
 
@@ -109,6 +112,7 @@ class GitHubCore(Generic[A]):
         user_agent: Optional[str] = None,
         follow_redirects: bool = True,
         timeout: Optional[Union[float, httpx.Timeout]] = None,
+        http_cache: bool = True,
     ):
         ...
 
@@ -123,6 +127,7 @@ class GitHubCore(Generic[A]):
         user_agent: Optional[str] = None,
         follow_redirects: bool = True,
         timeout: Optional[Union[float, httpx.Timeout]] = None,
+        http_cache: bool = True,
     ):
         auth = auth or UnauthAuthStrategy()  # type: ignore
         self.auth: A = (  # type: ignore
@@ -130,7 +135,13 @@ class GitHubCore(Generic[A]):
         )
 
         self.config = config or get_config(
-            base_url, accept_format, previews, user_agent, follow_redirects, timeout
+            base_url,
+            accept_format,
+            previews,
+            user_agent,
+            follow_redirects,
+            timeout,
+            http_cache,
         )
 
         self.__sync_client: ContextVar[Optional[httpx.Client]] = ContextVar(
@@ -187,7 +198,14 @@ class GitHubCore(Generic[A]):
 
     # create sync client
     def _create_sync_client(self) -> httpx.Client:
-        return httpx.Client(**self._get_client_defaults())
+        if self.config.http_cache:
+            transport = hishel.CacheTransport(
+                httpx.HTTPTransport(), storage=hishel.InMemoryStorage()
+            )
+        else:
+            transport = httpx.HTTPTransport()
+
+        return httpx.Client(**self._get_client_defaults(), transport=transport)
 
     # get or create sync client
     @contextmanager
@@ -203,7 +221,14 @@ class GitHubCore(Generic[A]):
 
     # create async client
     def _create_async_client(self) -> httpx.AsyncClient:
-        return httpx.AsyncClient(**self._get_client_defaults())
+        if self.config.http_cache:
+            transport = hishel.AsyncCacheTransport(
+                httpx.AsyncHTTPTransport(), storage=hishel.AsyncInMemoryStorage()
+            )
+        else:
+            transport = httpx.AsyncHTTPTransport()
+
+        return httpx.AsyncClient(**self._get_client_defaults(), transport=transport)
 
     # get or create async client
     @asynccontextmanager

githubkit/github.py

@@ -15,9 +15,9 @@ from typing import (
 
 from .core import GitHubCore
 from .response import Response
-from .rest import RestNamespace
 from .paginator import Paginator
 from .auth import BaseAuthStrategy
+from .versions import RestVersionSwitcher, WebhooksVersionSwitcher
 from .graphql import GraphQLResponse, build_graphql_request, parse_graphql_response
 
 if TYPE_CHECKING:
@@ -84,6 +84,7 @@ class GitHub(GitHubCore[A]):
             user_agent: Optional[str] = None,
             follow_redirects: bool = True,
             timeout: Optional[Union[float, httpx.Timeout]] = None,
+            http_cache: bool = True,
         ):
             ...
 
@@ -99,6 +100,7 @@ class GitHub(GitHubCore[A]):
             user_agent: Optional[str] = None,
             follow_redirects: bool = True,
             timeout: Optional[Union[float, httpx.Timeout]] = None,
+            http_cache: bool = True,
         ):
             ...
 
@@ -114,6 +116,7 @@ class GitHub(GitHubCore[A]):
             user_agent: Optional[str] = None,
             follow_redirects: bool = True,
             timeout: Optional[Union[float, httpx.Timeout]] = None,
+            http_cache: bool = True,
         ):
             ...
 
@@ -126,8 +129,11 @@ class GitHub(GitHubCore[A]):
 
     # rest api
     @cached_property
-    def rest(self) -> RestNamespace:
-        return RestNamespace(self)
+    def rest(self) -> RestVersionSwitcher:
+        return RestVersionSwitcher(self)
+
+    # webhooks
+    webhooks = WebhooksVersionSwitcher()
 
     # graphql
     def graphql(

githubkit/graphql/models.py

@@ -1,28 +1,28 @@
 from typing import Any, Dict, List, Union, Optional
 
-from pydantic import BaseModel, model_validator
+from githubkit.compat import GitHubModel, model_before_validator
 
 
-class SourceLocation(BaseModel):
+class SourceLocation(GitHubModel):
     line: int
     column: int
 
 
-class GraphQLError(BaseModel):
+class GraphQLError(GitHubModel):
     message: str
     locations: Optional[List[SourceLocation]] = None
     path: Optional[List[Union[int, str]]] = None
     extensions: Optional[Dict[str, Any]] = None
 
 
-class GraphQLResponse(BaseModel):
+class GraphQLResponse(GitHubModel):
     data: Optional[Dict[str, Any]] = None
     errors: Optional[List[GraphQLError]] = None
     extensions: Optional[Dict[str, Any]] = None
 
-    @model_validator(mode="before")
+    @model_before_validator
     @classmethod
-    def validate_data_and_errors(cls, values: Dict[str, Any]):
+    def _validate_data_and_errors(cls, values: Dict[str, Any]):
         if values.get("data") is None and not values.get("errors"):
             raise ValueError("No data or errors found in response")
         return values

githubkit/lazy_module.py

@@ -0,0 +1,121 @@
+import re
+import sys
+import importlib
+from itertools import chain
+from types import ModuleType
+from importlib.abc import MetaPathFinder
+from typing import Any, Dict, List, Tuple, Optional, Sequence
+from importlib.machinery import ModuleSpec, PathFinder, SourceFileLoader
+
+LAZY_MODULES = (
+    r"^githubkit\.rest$",
+    r"^githubkit\.versions\.v[^.]+\.models$",
+    r"^githubkit\.versions\.v[^.]+\.webhooks$",
+    r"^githubkit\.versions\.latest\.models$",
+    r"^githubkit\.versions\.latest\.types$",
+    r"^githubkit\.versions\.latest\.webhooks$",
+)
+
+
+class LazyModule(ModuleType):
+    __lazy_vars__: Dict[str, List[str]]
+    __lazy_vars_validated__: Optional[Dict[str, List[str]]]
+    __lazy_vars_mapping__: Dict[str, str]
+
+    @property
+    def __all__(self) -> Tuple[str, ...]:
+        lazy_vars = self.__lazy_vars_validated__
+        if lazy_vars is None:
+            return ()
+        return tuple(chain.from_iterable(lazy_vars.values()))
+
+    def __dir__(self):
+        result = list(super().__dir__())
+        for attr in self.__all__:
+            if attr not in result:
+                result.append(attr)
+        return result
+
+    def __getattr__(self, name: str) -> Any:
+        lazy_vars = self.__lazy_vars_validated__
+        # module may not initialized or not valid
+        if lazy_vars is None:
+            raise AttributeError(f"module '{self.__name__}' has no attribute '{name}'")
+
+        # check if the attribute is a lazy variable
+        if name in self.__lazy_vars_mapping__:
+            module = self._get_module(self.__lazy_vars_mapping__[name])
+            value = getattr(module, name)
+        else:
+            raise AttributeError(f"module '{self.__name__}' has no attribute '{name}'")
+
+        # cache the value
+        setattr(self, name, value)
+        return value
+
+    def _get_module(self, module_name: str) -> ModuleType:
+        try:
+            return importlib.import_module(module_name, self.__name__)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to import {module_name} from {self.__name__}"
+            ) from e
+
+    def __reduce__(self):
+        return (
+            self.__class__,
+            (self.__name__, self.__file__, getattr(self, "__lazy_vars__", None)),
+        )
+
+
+class LazyModuleLoader(SourceFileLoader):
+    def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]:
+        if self.name in sys.modules:
+            return sys.modules[self.name]
+        module = LazyModule(spec.name)
+        # pre-initialize the module to avoid infinite recursion
+        module.__lazy_vars_validated__ = None
+        module.__lazy_vars_mapping__ = {}
+        return module
+
+    def exec_module(self, module: LazyModule) -> None:
+        super().exec_module(module)
+
+        if getattr(module, "__lazy_vars_validated__", None) is None:
+            structure = getattr(module, "__lazy_vars__", None)
+            if isinstance(structure, dict) and all(
+                isinstance(key, str) and isinstance(value, (list, tuple, set))
+                for key, value in structure.items()
+            ):
+                module.__lazy_vars_validated__ = structure
+                module.__lazy_vars_mapping__ = {
+                    var: module
+                    for module, vars in module.__lazy_vars_validated__.items()
+                    for var in vars
+                }
+            else:
+                raise RuntimeError(
+                    f"Invalid lazy module structure for {module.__name__}"
+                )
+
+
+class LazyModuleFinder(MetaPathFinder):
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[Sequence[str]],
+        target: Optional[ModuleType] = None,
+    ) -> Optional[ModuleSpec]:
+        module_spec = PathFinder.find_spec(fullname, path, target)
+        if not module_spec or not module_spec.origin:
+            return module_spec
+
+        if module_spec and any(
+            re.match(pattern, module_spec.name) for pattern in LAZY_MODULES
+        ):
+            module_spec.loader = LazyModuleLoader(module_spec.name, module_spec.origin)
+        return module_spec
+
+
+def apply():
+    sys.meta_path.insert(0, LazyModuleFinder())

githubkit/response.py

@@ -1,7 +1,8 @@
 from typing import Any, Type, Generic, TypeVar
 
 import httpx
-from pydantic import TypeAdapter
+
+from .compat import type_validate_json
 
 RT = TypeVar("RT")
 
@@ -47,4 +48,4 @@ class Response(Generic[RT]):
 
     @property
     def parsed_data(self) -> RT:
-        return TypeAdapter(self._data_model).validate_json(self.content)
+        return type_validate_json(self._data_model, self.content)