hishel 0.1.4__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

hishel/_headers.py

@@ -1,215 +0,0 @@
-import string
-from typing import Any, Dict, List, Optional, Union
-
-from ._exceptions import ParseError, ValidationError
-
-## Grammar
-
-
-HTAB = "\t"
-SP = " "
-obs_text = "".join(chr(i) for i in range(0x80, 0xFF + 1))  # 0x80-0xFF
-
-tchar = "!#$%&'*+-.^_`|~0123456789" + string.ascii_letters
-qdtext = "".join(
-    [
-        HTAB,
-        SP,
-        "\x21",
-        "".join(chr(i) for i in range(0x23, 0x5B + 1)),  # 0x23-0x5b
-        "".join(chr(i) for i in range(0x5D, 0x7E + 1)),  # 0x5D-0x7E
-        obs_text,
-    ]
-)
-
-TIME_FIELDS = [
-    "max_age",
-    "max_stale",
-    "min_fresh",
-    "s_maxage",
-]
-
-BOOLEAN_FIELDS = [
-    "immutable",
-    "must_revalidate",
-    "must_understand",
-    "no_store",
-    "no_transform",
-    "only_if_cached",
-    "public",
-    "proxy_revalidate",
-]
-
-LIST_FIELDS = ["no_cache", "private"]
-
-__all__ = (
-    "CacheControl",
-    "Vary",
-)
-
-
-def strip_ows_around(text: str) -> str:
-    return text.strip(" ").strip("\t")
-
-
-def normalize_directive(text: str) -> str:
-    return text.replace("-", "_")
-
-
-def parse_cache_control(cache_control_values: List[str]) -> "CacheControl":
-    directives = {}
-
-    for cache_control_value in cache_control_values:
-        if "no-cache=" in cache_control_value or "private=" in cache_control_value:
-            cache_control_splited = [cache_control_value]
-        else:
-            cache_control_splited = cache_control_value.split(",")
-
-        for directive in cache_control_splited:
-            key: str = ""
-            value: Optional[str] = None
-            dquote = False
-
-            if not directive:
-                raise ParseError("The directive should not be left blank.")
-
-            directive = strip_ows_around(directive)
-
-            if not directive:
-                raise ParseError("The directive should not contain only whitespaces.")
-
-            for i, key_char in enumerate(directive):
-                if key_char == "=":
-                    value = directive[i + 1 :]
-
-                    if not value:
-                        raise ParseError("The directive value cannot be left blank.")
-
-                    if value[0] == '"':
-                        dquote = True
-                    if dquote and value[-1] != '"':
-                        raise ParseError("Invalid quotes around the value.")
-
-                    if not dquote:
-                        for value_char in value:
-                            if value_char not in tchar:
-                                raise ParseError(
-                                    f"The character '{value_char!r}' is not permitted for the unquoted values."
-                                )
-                    else:
-                        for value_char in value[1:-1]:
-                            if value_char not in qdtext:
-                                raise ParseError(
-                                    f"The character '{value_char!r}' is not permitted for the quoted values."
-                                )
-                    break
-
-                if key_char not in tchar:
-                    raise ParseError(f"The character '{key_char!r}' is not permitted in the directive name.")
-                key += key_char
-            directives[key] = value
-    validated_data = CacheControl.validate(directives)
-    return CacheControl(**validated_data)
-
-
-class Vary:
-    def __init__(self, values: List[str]) -> None:
-        self._values = values
-
-    @classmethod
-    def from_value(cls, vary_values: List[str]) -> "Vary":
-        values = []
-
-        for vary_value in vary_values:
-            for field_name in vary_value.split(","):
-                field_name = field_name.strip()
-                values.append(field_name)
-        return Vary(values)
-
-
-class CacheControl:
-    def __init__(
-        self,
-        immutable: bool = False,  # [RFC8246]
-        max_age: Optional[int] = None,  # [RFC9111, Section 5.2.1.1, 5.2.2.1]
-        max_stale: Optional[int] = None,  # [RFC9111, Section 5.2.1.2]
-        min_fresh: Optional[int] = None,  # [RFC9111, Section 5.2.1.3]
-        must_revalidate: bool = False,  # [RFC9111, Section 5.2.2.2]
-        must_understand: bool = False,  # [RFC9111, Section 5.2.2.3]
-        no_cache: Union[bool, List[str]] = False,  # [RFC9111, Section 5.2.1.4, 5.2.2.4]
-        no_store: bool = False,  # [RFC9111, Section 5.2.1.5, 5.2.2.5]
-        no_transform: bool = False,  # [RFC9111, Section 5.2.1.6, 5.2.2.6]
-        only_if_cached: bool = False,  # [RFC9111, Section 5.2.1.7]
-        private: Union[bool, List[str]] = False,  # [RFC9111, Section 5.2.2.7]
-        proxy_revalidate: bool = False,  # [RFC9111, Section 5.2.2.8]
-        public: bool = False,  # [RFC9111, Section 5.2.2.9]
-        s_maxage: Optional[int] = None,  # [RFC9111, Section 5.2.2.10]
-    ) -> None:
-        self.immutable = immutable
-        self.max_age = max_age
-        self.max_stale = max_stale
-        self.min_fresh = min_fresh
-        self.must_revalidate = must_revalidate
-        self.must_understand = must_understand
-        self.no_cache = no_cache
-        self.no_store = no_store
-        self.no_transform = no_transform
-        self.only_if_cached = only_if_cached
-        self.private = private
-        self.proxy_revalidate = proxy_revalidate
-        self.public = public
-        self.s_maxage = s_maxage
-
-    @classmethod
-    def validate(cls, directives: Dict[str, Any]) -> Dict[str, Any]:
-        validated_data: Dict[str, Any] = {}
-
-        for key, value in directives.items():
-            key = normalize_directive(key)
-            if key in TIME_FIELDS:
-                if value is None:
-                    raise ValidationError(f"The directive '{key}' necessitates a value.")
-
-                if value[0] == '"' or value[-1] == '"':
-                    raise ValidationError(f"The argument '{key}' should be an integer, but a quote was found.")
-
-                try:
-                    validated_data[key] = int(value)
-                except Exception:
-                    raise ValidationError(f"The argument '{key}' should be an integer, but got '{value!r}'.")
-            elif key in BOOLEAN_FIELDS:
-                if value is not None:
-                    raise ValidationError(f"The directive '{key}' should have no value, but it does.")
-                validated_data[key] = True
-            elif key in LIST_FIELDS:
-                if value is None:
-                    validated_data[key] = True
-                else:
-                    values = []
-                    for list_value in value[1:-1].split(","):
-                        if not list_value:
-                            raise ValidationError("The list value must not be empty.")
-                        list_value = strip_ows_around(list_value)
-                        values.append(list_value)
-                    validated_data[key] = values
-
-        return validated_data
-
-    def __repr__(self) -> str:
-        fields = ""
-
-        for key in TIME_FIELDS:
-            key = key.replace("-", "_")
-            value = getattr(self, key)
-            if value:
-                fields += f"{key}={value}, "
-
-        for key in BOOLEAN_FIELDS:
-            key = key.replace("-", "_")
-            value = getattr(self, key)
-            if value:
-                fields += f"{key}, "
-
-        fields = fields[:-2]
-
-        return f"<{type(self).__name__} {fields}>"

hishel/_lfu_cache.py

@@ -1,71 +0,0 @@
-from collections import OrderedDict
-from typing import DefaultDict, Dict, Generic, Iterator, Tuple, TypeVar
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-__all__ = ["LFUCache"]
-
-
-class LFUCache(Generic[K, V]):
-    def __init__(self, capacity: int):
-        if capacity <= 0:
-            raise ValueError("Capacity must be positive")
-
-        self.capacity = capacity
-        self.cache: Dict[K, Tuple[V, int]] = {}  # To store key-value pairs
-        self.freq_count: DefaultDict[int, OrderedDict[K, V]] = DefaultDict(
-            OrderedDict
-        )  # To store frequency of each key
-        self.min_freq = 0  # To keep track of the minimum frequency
-
-    def get(self, key: K) -> V:
-        if key in self.cache:
-            value, freq = self.cache[key]
-            # Update frequency and move the key to the next frequency bucket
-            self.freq_count[freq].pop(key)
-            if not self.freq_count[freq]:  # If the current frequency has no keys, update min_freq
-                del self.freq_count[freq]
-                if freq == self.min_freq:
-                    self.min_freq += 1
-            freq += 1
-            self.freq_count[freq][key] = value
-            self.cache[key] = (value, freq)
-            return value
-        raise KeyError(f"Key {key} not found")
-
-    def put(self, key: K, value: V) -> None:
-        if key in self.cache:
-            _, freq = self.cache[key]
-            # Update frequency and move the key to the next frequency bucket
-            self.freq_count[freq].pop(key)
-            if not self.freq_count[freq]:
-                del self.freq_count[freq]
-                if freq == self.min_freq:
-                    self.min_freq += 1
-            freq += 1
-            self.freq_count[freq][key] = value
-            self.cache[key] = (value, freq)
-        else:
-            # Check if cache is full, evict the least frequently used item
-            if len(self.cache) == self.capacity:
-                evicted_key, _ = self.freq_count[self.min_freq].popitem(last=False)
-                del self.cache[evicted_key]
-
-            # Add the new key-value pair with frequency 1
-            self.cache[key] = (value, 1)
-            self.freq_count[1][key] = value
-            self.min_freq = 1
-
-    def remove_key(self, key: K) -> None:
-        if key in self.cache:
-            _, freq = self.cache[key]
-            self.freq_count[freq].pop(key)
-            if not self.freq_count[freq]:  # If the current frequency has no keys, update min_freq
-                del self.freq_count[freq]
-                if freq == self.min_freq:
-                    self.min_freq += 1
-            del self.cache[key]
-
-    def __iter__(self) -> Iterator[K]:
-        yield from self.cache

hishel/_lmdb_types_.pyi

@@ -1,53 +0,0 @@
-from contextlib import contextmanager
-from typing import Any, Iterator
-
-class Database: ...
-
-class Transaction:
-    def get(self, key: bytes, *, db: Database | None = None) -> bytes | None:
-        """
-        Get the value associated with the given key.
-        """
-        pass
-
-    def put(self, key: bytes, value: bytes, *, db: Database | None = None, dupdata: bool = False) -> None:
-        """
-        Put a key-value pair into the database.
-        """
-        pass
-
-    def delete(self, key: bytes, *, db: Database | None = None) -> bool:
-        """
-        Delete the key from the database.
-        """
-        pass
-
-    def cursor(self, db: Database) -> Any:
-        """
-        Create a cursor for iterating over key-value pairs in the database.
-        """
-        pass
-
-class Environment:
-    @contextmanager
-    def begin(self, *, db: Database | None = None, write: bool = False) -> Iterator[Transaction]:
-        """
-        Begin a transaction in the environment.
-        """
-        raise NotImplementedError("It's only for type hinting purposes")
-
-    def open_db(self, key: bytes, dupsort: bool = False) -> Database:
-        """
-        Open a database within the environment.
-        """
-        raise NotImplementedError("It's only for type hinting purposes")
-
-def open(
-    path: str,
-    *,
-    max_dbs: int = 0,
-) -> Environment:
-    """
-    Open an LMDB environment at the specified path.
-    """
-    raise NotImplementedError("It's only for type hinting purposes")

hishel/_s3.py

@@ -1,122 +0,0 @@
-import time
-import typing as tp
-
-from anyio import to_thread
-from botocore.exceptions import ClientError
-
-
-def get_timestamp_in_ms() -> float:
-    return time.time() * 1000
-
-
-class S3Manager:
-    def __init__(
-        self,
-        client: tp.Any,
-        bucket_name: str,
-        check_ttl_every: tp.Union[int, float],
-        is_binary: bool = False,
-        path_prefix: str = "hishel-",
-    ):
-        self._client = client
-        self._bucket_name = bucket_name
-        self._is_binary = is_binary
-        self._last_cleaned = time.monotonic()
-        self._check_ttl_every = check_ttl_every
-        self._path_prefix = path_prefix
-
-    def write_to(self, path: str, data: tp.Union[bytes, str], only_metadata: bool = False) -> None:
-        path = self._path_prefix + path
-        if isinstance(data, str):
-            data = data.encode("utf-8")
-
-        created_at = None
-        if only_metadata:
-            try:
-                response = self._client.get_object(
-                    Bucket=self._bucket_name,
-                    Key=path,
-                )
-                created_at = response["Metadata"]["created_at"]
-            except Exception:
-                pass
-
-        self._client.put_object(
-            Bucket=self._bucket_name,
-            Key=path,
-            Body=data,
-            Metadata={"created_at": created_at or str(get_timestamp_in_ms())},
-        )
-
-    def read_from(self, path: str) -> tp.Union[bytes, str]:
-        path = self._path_prefix + path
-        response = self._client.get_object(
-            Bucket=self._bucket_name,
-            Key=path,
-        )
-
-        content = response["Body"].read()
-
-        if self._is_binary:  # pragma: no cover
-            return tp.cast(bytes, content)
-
-        return tp.cast(str, content.decode("utf-8"))
-
-    def remove_expired(self, ttl: int, key: str) -> None:
-        path = self._path_prefix + key
-
-        if time.monotonic() - self._last_cleaned < self._check_ttl_every:
-            try:
-                response = self._client.get_object(Bucket=self._bucket_name, Key=path)
-                if get_timestamp_in_ms() - float(response["Metadata"]["created_at"]) > ttl:
-                    self._client.delete_object(Bucket=self._bucket_name, Key=path)
-                return
-            except ClientError as e:
-                if e.response["Error"]["Code"] == "NoSuchKey":
-                    return
-                raise e
-
-        self._last_cleaned = time.monotonic()
-        for obj in self._client.list_objects(Bucket=self._bucket_name).get("Contents", []):
-            if not obj["Key"].startswith(self._path_prefix):  # pragma: no cover
-                continue
-
-            try:
-                metadata_obj = self._client.head_object(Bucket=self._bucket_name, Key=obj["Key"]).get("Metadata", {})
-            except ClientError as e:
-                if e.response["Error"]["Code"] == "404":
-                    continue
-
-            if not metadata_obj or "created_at" not in metadata_obj:
-                continue
-
-            if get_timestamp_in_ms() - float(metadata_obj["created_at"]) > ttl:
-                self._client.delete_object(Bucket=self._bucket_name, Key=obj["Key"])
-
-    def remove_entry(self, key: str) -> None:
-        path = self._path_prefix + key
-        self._client.delete_object(Bucket=self._bucket_name, Key=path)
-
-
-class AsyncS3Manager:  # pragma: no cover
-    def __init__(
-        self,
-        client: tp.Any,
-        bucket_name: str,
-        check_ttl_every: tp.Union[int, float],
-        is_binary: bool = False,
-        path_prefix: str = "hishel-",
-    ):
-        self._sync_manager = S3Manager(client, bucket_name, check_ttl_every, is_binary, path_prefix)
-
-    async def write_to(self, path: str, data: tp.Union[bytes, str], only_metadata: bool = False) -> None:
-        return await to_thread.run_sync(self._sync_manager.write_to, path, data, only_metadata)
-
-    async def read_from(self, path: str) -> tp.Union[bytes, str]:
-        return await to_thread.run_sync(self._sync_manager.read_from, path)
-
-    async def remove_expired(self, ttl: int, key: str) -> None:
-        return await to_thread.run_sync(self._sync_manager.remove_expired, ttl, key)
-
-    async def remove_entry(self, key: str) -> None:
-        return await to_thread.run_sync(self._sync_manager.remove_entry, key)