core

def __init__(
    self,
    user: User | None = None,
    prefix_url: str = settings.ITKDB_API_URL,
    save_auth: Path | str | None = None,
    cache: bool | object = True,
    expires_after: dict[str, int] | None = None,
    auth_expiry_threshold: int = 15,
):
    super().__init__()
    self.headers.update({"User-Agent": f"itkdb/{__version__}"})
    self.user: UserLike = (
        user
        if user
        else User(save_auth=save_auth, auth_expiry_threshold=auth_expiry_threshold)
    )
    self.auth: Callable[[requests.PreparedRequest], requests.PreparedRequest] = (
        self.authorize
    )
    self.prefix_url: str = prefix_url
    # store last call
    self._response: requests.Response | None = None

    cache_options = {}
    if cache:
        cache = (
            cachecontrol.caches.file_cache.FileCache(".webcache")
            if cache is True
            else cache
        )
        cache_options.update({"cache": cache})

    # handle expirations for cache
    if expires_after and isinstance(expires_after, dict):
        cache_options.update({"heuristic": ExpiresAfter(**expires_after)})

    if cache_options:
        # add caching
        super().mount(
            self.prefix_url,
            CacheControlAdapter(controller_class=CacheController, **cache_options),
        )

def __init__(
    self,
    access_code1: str = settings.ITKDB_ACCESS_CODE1,
    access_code2: str = settings.ITKDB_ACCESS_CODE2,
    audience: str = settings.ITKDB_ACCESS_AUDIENCE,
    prefix_url: str = settings.ITKDB_AUTH_URL,
    jwt_options: dict[str, Any] | None = None,
    save_auth: Path | str | None = None,
    auth_expiry_threshold: int = 15,
):
    # session handling (for injection in tests)
    self._session = requests.Session()
    self._session.headers.update({"User-Agent": f"itkdb/{__version__}"})
    # store last call to authenticate
    self._response: requests.Response | None = None
    self._status_code: int | None = None
    # store jwks for validation/verification
    self._jwks: dict[str, Any] | None = None
    # store information after authorization occurs
    self._access_token: str | None = None
    self._raw_id_token: str | None = None
    self._id_token: dict[str, Any] | None = None
    # initialization configuration
    self._access_code1: str = access_code1
    self._access_code2: str = access_code2
    self._audience: str = audience
    self._prefix_url: str = prefix_url
    # update jwt_options if provided
    self._jwt_options: dict[str, Any] = {
        "leeway": int(settings.ITKDB_LEEWAY)
    }  # **jwt_options, python3 only
    self._jwt_options.update(jwt_options or {})
    # serialization/persistence
    self._save_auth: Path | None = Path(save_auth) if save_auth else None
    self.auth_expiry_threshold: int = auth_expiry_threshold
    self._load()

def __init__(
    self,
    bearer: str = settings.ITKDB_AUDREYTWO_API_KEY,
):
    # session handling (for injection in tests)
    self._session = requests.Session()
    self._session.headers.update({"User-Agent": f"itkdb/{__version__}"})
    # store last call to authenticate
    self._response: requests.Response | None = None
    self._status_code: int | None = None
    # initialization configuration
    self._bearer: str = bearer