meta-memcache 2.0.0a1.dev6__tar.gz → 2.0.0a1.dev7__tar.gz

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meta-memcache
-Version: 2.0.0a1.dev6
+Version: 2.0.0a1.dev7
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Home-page: https://github.com/RevenueCat/meta-memcache-py
 License: MIT
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: marisa-trie (>=1.0.0,<2.0.0)
+Requires-Dist: meta-memcache-socket (>=0.1.0,<0.2.0)
 Requires-Dist: uhashring (>=2.1,<3.0)
 Project-URL: Repository, https://github.com/RevenueCat/meta-memcache-py
 Description-Content-Type: text/markdown

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "meta-memcache"
-version = "2.0.0a1-dev6"
+version = "2.0.0a1-dev7"
 description = "Modern, pure python, memcache client with support for new meta commands."
 license = "MIT"
 readme = "README.md"
@@ -14,6 +14,7 @@ packages = [{include = "meta_memcache", from="src"}]
 python = "^3.8"
 uhashring = "^2.1"
 marisa-trie = "^1.0.0"
+meta-memcache-socket = "^0.1.0"
 
 [tool.poetry.group.extras.dependencies]
 prometheus-client = "^0.17.1"

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/__init__.py

@@ -40,6 +40,7 @@ from meta_memcache.protocol import (
     Miss,
     NotStored,
     ServerVersion,
+    ResponseFlags,
     SetMode,
     Success,
     TokenFlag,

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/commands/high_level_commands.py

@@ -287,23 +287,23 @@ class HighLevelCommandsMixin:
 
             if isinstance(result, Value):
                 # It is a hit.
-                if result.win:
+                if result.flags.win:
                     # Win flag present, meaning we got the lease to
                     # recache/cache the item. We need to mimic a miss.
-                    return None, result.cas_token
-                if result.size == 0 and result.win is False:
+                    return None, result.flags.cas_token
+                if result.size == 0 and result.flags.win is False:
                     # The value is empty, this is a miss lease,
                     # and we lost, so we must keep retrying and
-                    # wait for the winner to populate the value.
+                    # wait for the.flags.winner to populate the value.
                     if i < lease_policy.miss_retries:
                         continue
                     else:
                         # We run out of retries, behave as a miss
-                        return None, result.cas_token
+                        return None, result.flags.cas_token
                 else:
                     # There is data, either the is no lease or
                     # we lost and should use the stale value.
-                    return result.value, result.cas_token
+                    return result.value, result.flags.cas_token
             else:
                 # With MISS_LEASE_TTL we should always get a value
                 # because on miss a lease empty value is generated
@@ -378,7 +378,7 @@ class HighLevelCommandsMixin:
         if result is None:
             return None, None
         else:
-            return result.value, result.cas_token
+            return result.value, result.flags.cas_token
 
     def _get(
         self: HighLevelCommandMixinWithMetaCommands,
@@ -414,7 +414,7 @@ class HighLevelCommandsMixin:
     ) -> Optional[Value]:
         if isinstance(result, Value):
             # It is a hit
-            if result.win:
+            if result.flags.win:
                 # Win flag present, meaning we got the lease to
                 # recache the item. We need to mimic a miss, so
                 # we set the value to None.

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/connection/memcache_socket.py

@@ -1,17 +1,21 @@
 import logging
 import socket
-from typing import Union
+from typing import Optional, Tuple, Union
+
+import meta_memcache_socket
 
 from meta_memcache.errors import MemcacheError
 from meta_memcache.protocol import (
     ENDL,
     ENDL_LEN,
+    EMPTY_RESPONSE_FLAGS,
     NOOP,
     Conflict,
     Miss,
     NotStored,
     ServerVersion,
     Success,
+    ResponseFlags,
     Value,
     get_store_success_response_header,
 )
@@ -119,7 +123,9 @@ class MemcacheSocket:
         self._pos = 0
         self._read = remaining_data
 
-    def _get_single_header(self) -> memoryview:
+    def _get_single_header(
+        self,
+    ) -> Tuple[int, Optional[int], Optional[int], Optional[ResponseFlags]]:
         # Reset buffer for new data
         if self._read == self._pos:
             self._read = 0
@@ -127,22 +133,19 @@ class MemcacheSocket:
         elif self._pos > self._reset_buffer_size:
             self._reset_buffer()
 
-        endl_pos = -1
         while True:
-            if self._read - self._pos > ENDL_LEN:
-                endl_pos = self._buf.find(ENDL, self._pos, self._read)
-                if endl_pos >= 0:
-                    break
+            if self._read != self._pos:
+                # We have data in the buffer: find the header
+                if header_data := meta_memcache_socket.parse_header(
+                    self._buf_view, self._pos, self._read
+                ):
+                    self._pos = header_data[0]
+                    return header_data
             # Missing data, but still space in buffer, so read more
             if self._recv_info_buffer() <= 0:
                 break
 
-        if endl_pos < 0:
-            raise MemcacheError("Bad response. Socket might have closed unexpectedly")
-
-        pos = self._pos
-        self._pos = endl_pos + ENDL_LEN
-        return self._buf_view[pos:endl_pos]
+        raise MemcacheError("Bad response. Socket might have closed unexpectedly")
 
     def sendall(self, data: bytes, with_noop: bool = False) -> None:
         if with_noop:
@@ -153,10 +156,12 @@ class MemcacheSocket:
     def _read_until_noop_header(self) -> None:
         while self._noop_expected > 0:
             header = self._get_single_header()
-            if header[0:2] == b"MN":
+            if header[1] == meta_memcache_socket.RESPONSE_NOOP:
                 self._noop_expected -= 1
 
-    def _get_header(self) -> memoryview:
+    def _get_header(
+        self,
+    ) -> Tuple[int, Optional[int], Optional[int], Optional[ResponseFlags]]:
         try:
             if self._noop_expected > 0:
                 self._read_until_noop_header()
@@ -169,30 +174,36 @@ class MemcacheSocket:
     def get_response(
         self,
     ) -> Union[Value, Success, NotStored, Conflict, Miss]:
-        header = self._get_header().tobytes()
-        response_code = header[0:2]
+        (_, response_code, size, flags) = self._get_header()
         result: Union[Value, Success, NotStored, Conflict, Miss]
         try:
-            if response_code == b"VA":
+            if response_code == meta_memcache_socket.RESPONSE_VALUE:
+                if size is None:
+                    raise MemcacheError("Bad value response. Missing size")
                 # Value response
-                result = Value.from_header(header)
-            elif response_code == self._store_success_response_header:
+                result = Value(
+                    size=size, flags=flags or EMPTY_RESPONSE_FLAGS, value=None
+                )
+            elif response_code == meta_memcache_socket.RESPONSE_SUCCESS:
                 # Stored or no value, return Success
-                result = Success.from_header(header)
-            elif response_code == b"NS":
+                result = Success(flags=flags or EMPTY_RESPONSE_FLAGS)
+            elif response_code == meta_memcache_socket.RESPONSE_NOT_STORED:
                 # Value response, parse size and flags
                 result = NOT_STORED
-            elif response_code == b"EX":
+            elif response_code == meta_memcache_socket.RESPONSE_CONFLICT:
                 # Already exists, not changed, CAS conflict
                 result = CONFLICT
-            elif response_code == b"EN" or response_code == b"NF":
+            elif response_code == meta_memcache_socket.RESPONSE_MISS:
                 # Not Found, Miss.
                 result = MISS
             else:
-                raise MemcacheError(f"Unknown response: {bytes(response_code)!r}")
+                raise MemcacheError(f"Unknown response: {response_code}")
         except Exception as e:
-            _log.warning(f"Error parsing response header in {self}: {header!r}")
-            raise MemcacheError(f"Error parsing response header {header!r}") from e
+            _log.warning(
+                f"Error parsing response header in {self}: "
+                f"Response: {response_code}, size {size}, flags: {flags}"
+            )
+            raise MemcacheError("Error parsing response header") from e
 
         return result
 

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/executors/default.py

@@ -17,6 +17,7 @@ from meta_memcache.protocol import (
     MetaCommand,
     Miss,
     NotStored,
+    ResponseFlags,
     ServerVersion,
     Success,
     TokenFlag,
@@ -252,12 +253,12 @@ class DefaultExecutor:
         Read response on a connection
         """
         if flags and Flag.NOREPLY in flags:
-            return Success()
+            return Success(flags=ResponseFlags())
         result = conn.get_response()
         if isinstance(result, Value):
             data = conn.get_value(result.size)
             if result.size > 0:
-                encoding_id = result.client_flag or 0
+                encoding_id = result.flags.client_flag or 0
                 try:
                     result.value = self._serializer.unserialize(data, encoding_id)
                 except Exception:

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/extras/migrating_cache_client.py

@@ -78,7 +78,11 @@ class MigratingCacheClient(HighLevelCommandsMixin):
             return current_mode
 
     def _get_value_ttl(self, value: Value) -> int:
-        ttl = value.ttl if value.ttl is not None else self._default_read_backfill_ttl
+        ttl = (
+            value.flags.ttl
+            if value.flags.ttl is not None
+            else self._default_read_backfill_ttl
+        )
         if ttl < 0:
             # TTL for items marked to store forvered is returned as -1
             ttl = 0

{meta_memcache-2.0.0a1.dev6 → meta_memcache-2.0.0a1.dev7}/src/meta_memcache/extras/probabilistic_hot_cache.py

@@ -124,10 +124,11 @@ class ProbabilisticHotCache(ClientWrapper):
         allowed: bool,
     ) -> None:
         if not is_hot:
-            hit_after_write = value.fetched or 0
-            last_read_age = value.last_access if value.last_access is not None else 9999
+            last_read_age = (
+                value.flags.last_access if value.flags.last_access is not None else 9999
+            )
             if (
-                hit_after_write > 0
+                value.flags.fetched
                 and last_read_age <= self._max_last_access_age_seconds
             ):
                 # Is detected as hot

meta_memcache-2.0.0a1.dev7/src/meta_memcache/protocol.py

@@ -0,0 +1,177 @@
+from dataclasses import dataclass
+from enum import Enum, IntEnum
+from typing import Any, Dict, List, Optional, Union
+
+from meta_memcache_socket import ResponseFlags
+
+ENDL = b"\r\n"
+NOOP: bytes = b"mn" + ENDL
+ENDL_LEN = 2
+SPACE: int = ord(" ")
+
+
+@dataclass
+class Key:
+    __slots__ = ("key", "routing_key", "is_unicode")
+    key: str
+    routing_key: Optional[str]
+    is_unicode: bool
+
+    def __init__(
+        self,
+        key: str,
+        routing_key: Optional[str] = None,
+        is_unicode: bool = False,
+    ) -> None:
+        self.key = key
+        self.routing_key = routing_key
+        self.is_unicode = is_unicode
+
+    def __hash__(self) -> int:
+        return hash((self.key, self.routing_key))
+
+
+class MetaCommand(Enum):
+    META_GET = b"mg"  # Meta Get
+    META_SET = b"ms"  # Meta Set
+    META_DELETE = b"md"  # Meta Delete
+    META_ARITHMETIC = b"ma"  # Meta Arithmetic
+
+
+class SetMode(Enum):
+    SET = b"S"  # Default
+    ADD = b"E"  # Add if item does NOT EXIST, else LRU bump and return NS
+    APPEND = b"A"  # If item exists, append the new value to its data.
+    PREPEND = b"P"  # If item exists, prepend the new value to its data.
+    REPLACE = b"R"  # Set only if item already exists.
+
+
+class Flag(Enum):
+    BINARY = b"b"
+    NOREPLY = b"q"
+    RETURN_CLIENT_FLAG = b"f"
+    RETURN_CAS_TOKEN = b"c"
+    RETURN_VALUE = b"v"
+    RETURN_TTL = b"t"
+    RETURN_SIZE = b"s"
+    RETURN_LAST_ACCESS = b"l"
+    RETURN_FETCHED = b"h"
+    RETURN_KEY = b"k"
+    NO_UPDATE_LRU = b"u"
+    MARK_STALE = b"I"
+
+
+class IntFlag(Enum):
+    CACHE_TTL = b"T"
+    RECACHE_TTL = b"R"
+    MISS_LEASE_TTL = b"N"
+    SET_CLIENT_FLAG = b"F"
+    MA_INITIAL_VALUE = b"J"
+    MA_DELTA_VALUE = b"D"
+    CAS_TOKEN = b"C"
+
+
+class TokenFlag(Enum):
+    OPAQUE = b"O"
+    # 'M' (mode switch):
+    # * Meta Arithmetic:
+    #  - I or +: increment
+    #  - D or -: decrement
+    # * Meta Set: See SetMode Enum above
+    #  - E: "add" command. LRU bump and return NS if item exists. Else add.
+    #  - A: "append" command. If item exists, append the new value to its data.
+    #  - P: "prepend" command. If item exists, prepend the new value to its data.
+    #  - R: "replace" command. Set only if item already exists.
+    #  - S: "set" command. The default mode, added for completeness.
+    MODE = b"M"
+
+
+# Store maps of byte values (int) to enum value
+flag_values: Dict[int, Flag] = {f.value[0]: f for f in Flag}
+int_flags_values: Dict[int, IntFlag] = {f.value[0]: f for f in IntFlag}
+token_flags_values: Dict[int, TokenFlag] = {f.value[0]: f for f in TokenFlag}
+
+
+@dataclass
+class MemcacheResponse:
+    __slots__ = ()
+
+
+@dataclass
+class Miss(MemcacheResponse):
+    __slots__ = ()
+
+    pass
+
+
+# Response flags
+EMPTY_RESPONSE_FLAGS = ResponseFlags()
+
+
+@dataclass
+class Success(MemcacheResponse):
+    __slots__ = ("flags",)
+    flags: ResponseFlags
+
+    @classmethod
+    def default(cls) -> "Success":
+        return cls(flags=ResponseFlags())
+
+
+@dataclass
+class Value(Success):
+    __slots__ = ("flags", "size", "value")
+    size: int
+    value: Optional[Any]
+
+
+@dataclass
+class ValueContainer:
+    __slots__ = ("value",)
+    value: Any
+
+
+MaybeValue = Optional[ValueContainer]
+MaybeValues = Optional[List[ValueContainer]]
+
+
+@dataclass
+class NotStored(MemcacheResponse):
+    __slots__ = ()
+
+
+@dataclass
+class Conflict(MemcacheResponse):
+    __slots__ = ()
+
+
+ReadResponse = Union[Miss, Value, Success]
+WriteResponse = Union[Success, NotStored, Conflict, Miss]
+
+
+Blob = Union[bytes, bytearray, memoryview]
+
+
+class ServerVersion(IntEnum):
+    """
+    If more versions with breaking changes are
+    added, bump stable to the next int. Code
+    will be able to use > / < / = to code
+    the behavior of the different versions.
+    """
+
+    AWS_1_6_6 = 1
+    STABLE = 2
+
+
+def get_store_success_response_header(version: ServerVersion) -> bytes:
+    if version == ServerVersion.AWS_1_6_6:
+        return b"OK"
+    return b"HD"
+
+
+def encode_size(size: int, version: ServerVersion) -> bytes:
+    if version == ServerVersion.AWS_1_6_6:
+        return b"S" + str(size).encode("ascii")
+    else:
+        return str(size).encode("ascii")

meta_memcache-2.0.0a1.dev6/src/meta_memcache/protocol.py

@@ -1,318 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum, IntEnum
-from typing import Any, Dict, List, Optional, Union
-
-ENDL = b"\r\n"
-NOOP: bytes = b"mn" + ENDL
-ENDL_LEN = 2
-SPACE: int = ord(" ")
-
-
-@dataclass
-class Key:
-    __slots__ = ("key", "routing_key", "is_unicode")
-    key: str
-    routing_key: Optional[str]
-    is_unicode: bool
-
-    def __init__(
-        self,
-        key: str,
-        routing_key: Optional[str] = None,
-        is_unicode: bool = False,
-    ) -> None:
-        self.key = key
-        self.routing_key = routing_key
-        self.is_unicode = is_unicode
-
-    def __hash__(self) -> int:
-        return hash((self.key, self.routing_key))
-
-
-class MetaCommand(Enum):
-    META_GET = b"mg"  # Meta Get
-    META_SET = b"ms"  # Meta Set
-    META_DELETE = b"md"  # Meta Delete
-    META_ARITHMETIC = b"ma"  # Meta Arithmetic
-
-
-class SetMode(Enum):
-    SET = b"S"  # Default
-    ADD = b"E"  # Add if item does NOT EXIST, else LRU bump and return NS
-    APPEND = b"A"  # If item exists, append the new value to its data.
-    PREPEND = b"P"  # If item exists, prepend the new value to its data.
-    REPLACE = b"R"  # Set only if item already exists.
-
-
-class Flag(Enum):
-    BINARY = b"b"
-    NOREPLY = b"q"
-    RETURN_CLIENT_FLAG = b"f"
-    RETURN_CAS_TOKEN = b"c"
-    RETURN_VALUE = b"v"
-    RETURN_TTL = b"t"
-    RETURN_SIZE = b"s"
-    RETURN_LAST_ACCESS = b"l"
-    RETURN_FETCHED = b"h"
-    RETURN_KEY = b"k"
-    NO_UPDATE_LRU = b"u"
-    MARK_STALE = b"I"
-
-
-class IntFlag(Enum):
-    CACHE_TTL = b"T"
-    RECACHE_TTL = b"R"
-    MISS_LEASE_TTL = b"N"
-    SET_CLIENT_FLAG = b"F"
-    MA_INITIAL_VALUE = b"J"
-    MA_DELTA_VALUE = b"D"
-    CAS_TOKEN = b"C"
-
-
-class TokenFlag(Enum):
-    OPAQUE = b"O"
-    # 'M' (mode switch):
-    # * Meta Arithmetic:
-    #  - I or +: increment
-    #  - D or -: decrement
-    # * Meta Set: See SetMode Enum above
-    #  - E: "add" command. LRU bump and return NS if item exists. Else add.
-    #  - A: "append" command. If item exists, append the new value to its data.
-    #  - P: "prepend" command. If item exists, prepend the new value to its data.
-    #  - R: "replace" command. Set only if item already exists.
-    #  - S: "set" command. The default mode, added for completeness.
-    MODE = b"M"
-
-
-# Store maps of byte values (int) to enum value
-flag_values: Dict[int, Flag] = {f.value[0]: f for f in Flag}
-int_flags_values: Dict[int, IntFlag] = {f.value[0]: f for f in IntFlag}
-token_flags_values: Dict[int, TokenFlag] = {f.value[0]: f for f in TokenFlag}
-
-
-@dataclass
-class MemcacheResponse:
-    __slots__ = ()
-
-
-@dataclass
-class Miss(MemcacheResponse):
-    __slots__ = ()
-
-    pass
-
-
-# Response flags
-TOKEN_FLAG_OPAQUE = ord("O")
-INT_FLAG_CAS_TOKEN = ord("c")
-INT_FLAG_FETCHED = ord("h")
-INT_FLAG_LAST_ACCESS = ord("l")
-INT_FLAG_TTL = ord("t")
-INT_FLAG_CLIENT_FLAG = ord("f")
-INT_FLAG_SIZE = ord("s")
-FLAG_WIN = ord("W")
-FLAG_LOST = ord("Z")
-FLAG_STALE = ord("X")
-
-
-# @dataclass(slots=True, init=False)
-@dataclass
-class Success(MemcacheResponse):
-    __slots__ = (
-        "cas_token",
-        "fetched",
-        "last_access",
-        "ttl",
-        "client_flag",
-        "win",
-        "stale",
-        "real_size",
-        "opaque",
-    )
-    cas_token: Optional[int]
-    fetched: Optional[int]
-    last_access: Optional[int]
-    ttl: Optional[int]
-    client_flag: Optional[int]
-    win: Optional[bool]
-    stale: bool
-    real_size: Optional[int]
-    opaque: Optional[bytes]
-
-    def __init__(
-        self,
-        *,
-        cas_token: Optional[int] = None,
-        fetched: Optional[int] = None,
-        last_access: Optional[int] = None,
-        ttl: Optional[int] = None,
-        client_flag: Optional[int] = None,
-        win: Optional[bool] = None,
-        stale: bool = False,
-        real_size: Optional[int] = None,
-        opaque: Optional[bytes] = None,
-    ) -> None:
-        self.cas_token = cas_token
-        self.fetched = fetched
-        self.last_access = last_access
-        self.ttl = ttl
-        self.client_flag = client_flag
-        self.win = win
-        self.stale = stale
-        self.real_size = real_size
-        self.opaque = opaque
-
-    @classmethod
-    def from_header(cls, header: "Blob") -> "Success":
-        result = cls()
-        result._set_flags(header)
-        return result
-
-    def _set_flags(self, header: bytes, pos: int = 3) -> None:  # noqa: C901
-        header_size = len(header)
-        while pos < header_size:
-            flag = header[pos]
-            pos += 1
-            if flag == SPACE:
-                continue
-            end = pos
-            while end < header_size:
-                if header[end] == SPACE:
-                    break
-                end += 1
-
-            if flag == INT_FLAG_CAS_TOKEN:
-                self.cas_token = int(header[pos:end])
-            elif flag == INT_FLAG_FETCHED:
-                self.fetched = int(header[pos:end])
-            elif flag == INT_FLAG_LAST_ACCESS:
-                self.last_access = int(header[pos:end])
-            elif flag == INT_FLAG_TTL:
-                self.ttl = int(header[pos:end])
-            elif flag == INT_FLAG_CLIENT_FLAG:
-                self.client_flag = int(header[pos:end])
-            elif flag == FLAG_WIN:
-                self.win = True
-            elif flag == FLAG_LOST:
-                self.win = False
-            elif flag == FLAG_STALE:
-                self.stale = True
-            elif flag == INT_FLAG_SIZE:
-                self.real_size = int(header[pos:end])
-            elif flag == TOKEN_FLAG_OPAQUE:
-                self.opaque = header[pos:end]
-            pos = end + 1
-
-
-# @dataclass(slots=True, init=False)
-@dataclass
-class Value(Success):
-    __slots__ = (
-        "cas_token",
-        "fetched",
-        "last_access",
-        "ttl",
-        "client_flag",
-        "win",
-        "stale",
-        "real_size",
-        "opaque",
-        "size",
-        "value",
-    )
-    size: int
-    value: Optional[Any]
-
-    def __init__(
-        self,
-        *,
-        size: int,
-        value: Optional[Any] = None,
-        cas_token: Optional[int] = None,
-        fetched: Optional[int] = None,
-        last_access: Optional[int] = None,
-        ttl: Optional[int] = None,
-        client_flag: Optional[int] = None,
-        win: Optional[bool] = None,
-        stale: bool = False,
-        real_size: Optional[int] = None,
-        opaque: Optional[bytes] = None,
-    ) -> None:
-        self.size = size
-        self.value = value
-        self.cas_token = cas_token
-        self.fetched = fetched
-        self.last_access = last_access
-        self.ttl = ttl
-        self.client_flag = client_flag
-        self.win = win
-        self.stale = stale
-        self.real_size = real_size
-        self.opaque = opaque
-
-    @classmethod
-    def from_header(cls, header: "Blob") -> "Value":
-        header_size = len(header)
-        if header_size < 4 or header[2] != SPACE:
-            raise ValueError(f"Invalid header {header!r}")
-        end = 4
-        while end < header_size:
-            if header[end] == SPACE:
-                break
-            end += 1
-        size = int(header[3:end])
-        result = cls(size=size)
-        result._set_flags(header, pos=end + 1)
-        return result
-
-
-@dataclass
-class ValueContainer:
-    __slots__ = ("value",)
-    value: Any
-
-
-MaybeValue = Optional[ValueContainer]
-MaybeValues = Optional[List[ValueContainer]]
-
-
-@dataclass
-class NotStored(MemcacheResponse):
-    __slots__ = ()
-
-
-@dataclass
-class Conflict(MemcacheResponse):
-    __slots__ = ()
-
-
-ReadResponse = Union[Miss, Value, Success]
-WriteResponse = Union[Success, NotStored, Conflict, Miss]
-
-
-Blob = Union[bytes, bytearray, memoryview]
-
-
-class ServerVersion(IntEnum):
-    """
-    If more versions with breaking changes are
-    added, bump stable to the next int. Code
-    will be able to use > / < / = to code
-    the behavior of the different versions.
-    """
-
-    AWS_1_6_6 = 1
-    STABLE = 2
-
-
-def get_store_success_response_header(version: ServerVersion) -> bytes:
-    if version == ServerVersion.AWS_1_6_6:
-        return b"OK"
-    return b"HD"
-
-
-def encode_size(size: int, version: ServerVersion) -> bytes:
-    if version == ServerVersion.AWS_1_6_6:
-        return b"S" + str(size).encode("ascii")
-    else:
-        return str(size).encode("ascii")