zstdlib 0.0.7__tar.gz → 0.0.11__tar.gz

{zstdlib-0.0.7 → zstdlib-0.0.11}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: zstdlib
-Version: 0.0.7
+Version: 0.0.11
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
 Keywords: remote,pipe
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 

{zstdlib-0.0.7 → zstdlib-0.0.11}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "zstdlib"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.12",
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
 ]
@@ -14,7 +14,7 @@ keywords = ["remote", "pipe"]
 license = {text = "GPLv3"}
 description = "A set of useful python utilities"
 urls = {Homepage = "https://github.com/zwimer/zstdlib"}
-requires-python = ">= 3.10"
+requires-python = ">= 3.12"
 # dependencies = [
 #     # Client
 #     "zstandard[cffi]",
@@ -63,7 +63,7 @@ disable = [
 
 [tool.black]
 line-length = 110
-target-version = ["py310", "py311", "py312", "py313"]
+target-version = ["py312", "py313"]
 
 [tool.ruff]
 line-length = 110

{zstdlib-0.0.7 → zstdlib-0.0.11}/tests/log/test_cute.py

@@ -78,6 +78,28 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
         self.assertEqual(Color.bright_red_bg_yellow("CRITICAL".ljust(8)), l_name(5))
         self.assertEqual(Color.bright_red_bg_yellow("Level 60".ljust(8)), l_name(6))
 
+    def test_custom_dim_level(self) -> None:
+        name = "TestCuteFormatter.test_dim_level"
+        msg = "test"
+        with self.hijack(name, fmt=CuteFormatter(dim_level=5)) as log:
+            log.log(4, msg)
+            log.log(5, msg)
+        self.assertEqual(2, len(self.messages[log]))
+        l_name = lambda idx: self.messages[log][idx].split("|")[0].strip()
+        self.assertEqual(Color.dim("Level 4".ljust(8)), l_name(0))
+        self.assertEqual("Level 5", l_name(1))
+
+    def test_custom_level_color(self) -> None:
+        name = "TestCuteFormatter.test_custom_level_color"
+        msg = "test"
+        with self.hijack(name, fmt=CuteFormatter(level_colors={15: Color.bright_red_bg_yellow})) as log:
+            log.log(14, msg)
+            log.log(15, msg)
+        self.assertEqual(2, len(self.messages[log]))
+        l_name = lambda idx: self.messages[log][idx].split("|")[0].strip()
+        self.assertEqual("Level 14".ljust(8), l_name(0))
+        self.assertEqual(Color.bright_red_bg_yellow("Level 15".ljust(8)), l_name(1))
+
     def test_exception(self) -> None:
         name = "TestCuteFormatter.test_exception"
         with self.hijack(name, fmt=CuteFormatter()) as log:

{zstdlib-0.0.7 → zstdlib-0.0.11}/tests/test_enum.py

@@ -63,9 +63,9 @@ class TestEnumType(unittest.TestCase):
         class ET10(metaclass=EnumType):
             arg1: int = 0
 
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             ET10()
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             ET10.__init__({})
 
 
@@ -127,9 +127,9 @@ class TestEnum(unittest.TestCase):
         class E10(Enum):
             arg1: int = 0
 
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             E10()
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             E10.__init__({})
 
 

zstdlib-0.0.11/tests/test_io.py

@@ -0,0 +1,90 @@
+import tempfile
+import unittest
+
+from zstdlib.io import ProtectedFile, BinaryIO, TextIO, io
+
+
+class RamFile(tempfile.SpooledTemporaryFile):
+    """
+    A file-like object that stores its contents in memory.
+    """
+
+    rollover = None  # type: ignore
+
+    def __init__(self, *args, mode: str = "w+", **kwargs):
+        super().__init__(10**9, *args, mode=mode, **kwargs)
+
+    def load(self, x):
+        self.write(x)
+        self.flush()
+        self.seek(self.tell() - len(x))
+
+
+class TestIO(unittest.TestCase):
+
+    def test_init(self):
+        with RamFile(mode="wb+") as fb, RamFile() as fs:
+            ts = TextIO(fs)
+            tb = BinaryIO(fb)
+            with self.assertRaises(TypeError):
+                TextIO(fb)
+            with self.assertRaises(TypeError):
+                BinaryIO(fs)
+            self.assertIs(ts, io(fs))
+            self.assertIs(tb, io(fb))
+
+    def test_protected_file(self):
+        with RamFile() as f:
+            p = ProtectedFile(f)
+            self.assertIs(f, p.raw)
+            self.assertIs(f.mode, p.mode)
+            for i in ("read", "readline", "readlines", "readall", "seek"):
+                with self.assertRaises(AttributeError):
+                    getattr(p, i)
+
+    def test_unread(self):
+        with RamFile() as raw:
+            f = io(raw)
+            f.unread("hello")
+            self.assertEqual("hello", f._buffer)
+
+    def test_read(self):
+        with RamFile() as raw:
+            raw.load("foobaz")
+            f = io(raw)
+            # Test read of file
+            self.assertEqual("fo", f.read(2))
+            self.assertEqual("o", f.read(1))
+            # Test read of buffer
+            f.unread("bar")
+            self.assertEqual("b", f.read(1))
+            # Test read of file + buffer
+            f.unread("foob")
+            self.assertEqual("foobar", f.read(6))
+            f.unread("foobar")
+            self.assertEqual("foobarbaz", f.read())
+
+    def test_peek(self):
+        with RamFile() as raw:
+            f = io(raw)
+            f.unread("foo")
+            # Test peek of buffer
+            for i in range(3):
+                self.assertEqual("fo", f.peek(2))
+            self.assertEqual("foo", f.read())
+            # Test peek of file
+            raw.load("bar")
+            for i in range(3):
+                self.assertEqual("ba", f.peek(2))
+            self.assertEqual("bar", f.read())
+            # Test peek of both
+            f.unread("baz")
+            raw.load("qux")
+            for i in range(3):
+                for k in range(5):
+                    self.assertEqual("bazqu"[:k], f.peek(k))
+            self.assertEqual("bazqux", f.read())
+
+
+if __name__ == "__main__":
+    unittest.main()

{zstdlib-0.0.7 → zstdlib-0.0.11}/tests/test_singleton.py

@@ -23,7 +23,7 @@ class TestSingletonType(unittest.TestCase):
         class ST3(metaclass=SingletonType):
             pass
 
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
 
             class ST4(ST3):
                 pass
@@ -116,7 +116,7 @@ class TestSingleton(unittest.TestCase):
         class S3(Singleton):
             pass
 
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
 
             class S4(S3):
                 pass

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.0.7"
+__version__ = "0.0.11"
 
 from .not_set import NotSetType, NotSet
 from .frozen import Freezable, frozen
 from .singleton import Singleton
 from .enum import Enum
-from . import log
+from . import log, io

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/ansi.py

@@ -107,6 +107,12 @@ class Color(metaclass=_ColorMeta):
             raise TypeError("Cannot add non-Color to Color")
         return type(self)(code=f"{self.code[:-1]};{other.code[len(_PREFIX):]}")
 
+    def __eq__(self, other: object) -> bool:
+        """
+        :return: Whether the two colors are equal
+        """
+        return isinstance(other, type(self)) and self.code == other.code
+
     def __repr__(self) -> str:
         """
         :return: The ansi color code this object represents

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/enum.py

@@ -1,10 +1,6 @@
 import collections
 
 
-def _not_implemented(*_, **__):
-    raise NotImplementedError("Cannot instantiate this class")
-
-
 class EnumType(type):
     """
     Metaclass for uninstantiable Enum classes with required annotations and unique values
@@ -17,7 +13,7 @@ class EnumType(type):
         for bad in ("__init__", "__new__"):
             if bad in attrs:
                 raise AttributeError("Cannot define __init__ or __new__")
-            attrs[bad] = _not_implemented
+            attrs[bad] = None
         # Check annotations
         public = {i: k for i, k in attrs.items() if not i.startswith("__")}
         annotations = attrs.get("__annotations__", {})

zstdlib-0.0.11/zstdlib/io.py

@@ -0,0 +1,238 @@
+from io import (
+    IOBase,
+    TextIOBase as _PyRawTextIOBase,
+    RawIOBase as _PyRawIOBase,
+    BufferedIOBase as _PyBufferedIOBase,
+)
+from threading import RLock
+from itertools import chain
+from typing import Self
+import weakref
+
+
+__all__ = ("TextIO", "BinaryIO", "io")
+
+type _BinaryBase = _PyRawIOBase | _PyBufferedIOBase
+type _TextBase = _PyRawTextIOBase
+
+
+class ProtectedFile:
+    """
+    A wrapper around an IO object that prevents access to certain attributes
+    If absolutely necessary, users can access the raw object directly via .raw
+    """
+
+    PROTECTED_PREFIXES = ("read", "seek", "getbuffer", "getvalue", "detach")
+    __slots__ = ("raw",)
+
+    def __init__(self, raw: IOBase) -> None:
+        """
+        :param raw: The raw IO object to wrap, users can access it directly if they must
+        """
+        self.raw: IOBase = raw
+
+    def __getattr__(self, item):
+        """
+        Prevent access to certain attributes
+        """
+        if any(item.startswith(i) for i in self.PROTECTED_PREFIXES):
+            raise AttributeError(f"Attribute {item} is protected")
+        return getattr(self.raw, item)
+
+    def __hash__(self) -> int:
+        return hash(self.raw)
+
+
+# See bug: https://github.com/pylint-dev/pylint/issues/9335
+# pylint: disable=undefined-variable
+class _IOWrapperBase[T: (str, bytes)]:
+    """
+    A base class for IO objects that adds additional functionality such as readuntil, unread, and peek
+    These classes are singletons with respect to their input object
+    Note: This class takes ownership of the input object, do not use it elsewhere
+    """
+
+    __slots__ = ("lock", "f", "_buffer", "_eof")
+    _instances: weakref.WeakKeyDictionary[IOBase, Self] = weakref.WeakKeyDictionary()
+    _wr_lock = RLock()
+
+    def __new__(cls, f: IOBase, binary: bool) -> Self:
+        """
+        Create a new instance of cls for raw, or return an existing instance if one exists
+        """
+        with cls._wr_lock:
+            if (ret := cls._instances.get(f, None)) is None:
+                cls._instances[f] = (ret := super().__new__(cls))
+        return ret
+
+    def __init__(self, f: IOBase, *, binary: bool) -> None:
+        """
+        Initialize the IO object with a raw IO object
+        Note: This class takes ownership of the input object, do not use it elsewhere
+        :param f: The raw IO object to wrap
+        :param binary: If True, the IO object will read/write bytes, otherwise it will read/write strings
+        """
+        self._buffer: T = (bytes if binary else str)()  # type: ignore
+        self.f = ProtectedFile(f)
+        self.lock = RLock()
+
+    def read(self, size: int = -1) -> T:
+        """
+        Read up to size characters from self.raw or until EOF
+        If size is unspecified or -1, read until EOF
+        """
+        if size == 0:
+            return self._buffer[:0]
+        with self.lock:
+            ret = self._read_buffer(size)
+            if len(ret) == size:
+                return ret
+            ret += self._read(-1 if size == -1 else (size - len(ret)))
+        return ret
+
+    def readline(self) -> T:
+        """
+        Read a line from self.raw or until EOF
+        Newline is included in the return value
+        """
+        with self.lock:
+            nl: T = "\n" if isinstance(self._buffer, str) else b"\n"
+            ret = self._read_buffer(self._buffer.find(nl)) + self._read_buffer(1)
+            if ret.endswith(nl):
+                return ret
+            return ret + self.f.raw.readline()  # type: ignore
+
+    def readlines(self) -> list[T]:
+        """
+        Read all lines from self.raw until EOF
+        """
+        with self.lock:
+            ret: list[T] = []
+            while add := self.readline():
+                ret.append(add)
+            return ret
+
+    def peek(self, size: int = -1) -> T:
+        """
+        Read size characters from self.raw or until EOF, without consuming the data
+        """
+        with self.lock:
+            self.unread(ret := self.read(size))
+        return ret
+
+    def unread(self, data: T) -> None:
+        """
+        Unread data back to the internal buffer
+        """
+        with self.lock:
+            self._buffer = data + self._buffer
+
+    def readuntil(self, until: T, *, eof_ok: bool = True) -> T:
+        """
+        Read until until is found in f. If eof_ok is False, raise EOFError if until is not found before EOF.
+        :param until: The str/bytes to read until
+        :param inclusive: If True, the returned value will end with until
+        :param eof_ok: if False, raise EOFError if until is not found before EOF
+        :return: The data read from self.raw, up to and including until
+        """
+        if isinstance(until, str) ^ isinstance(self._buffer, str):
+            raise TypeError("until: expected same type as buffer")
+        if len(until) == 0:
+            raise ValueError("until may not be empty")
+        with self.lock:
+            if until in self._buffer:
+                return self._read_buffer(self._buffer.find(until) + len(until))
+            buffer = [self._read_buffer()]
+            # Use bytearray to avoid multiple concatenations
+            # Read until until is found, avoid small read() syscall's because they are slow
+            while (n := self._remainder(buffer, until)) and (add := self._read(n)):
+                buffer.append(add)
+            ret = buffer[0][:0].join(buffer)
+            if not ret.endswith(until) and not eof_ok:
+                raise EOFError("until: not found before EOF")
+            return ret
+
+    #
+    # Helper functions
+    #
+
+    def _read(self, size) -> T:
+        ret: T = self.f.raw.read(size)  # type: ignore
+        return ret if ret else self._buffer[:0]  # Some .read's can return None
+
+    def _read_buffer(self, size: int = -1) -> T:
+        if size == -1:
+            size = len(self._buffer)
+        ret: T = self._buffer[:size]
+        self._buffer = self._buffer[size:]
+        return ret
+
+    @staticmethod
+    def _remainder(data: list[T], suffix: T) -> int:
+        assert suffix, "suffix: expected non-empty str or bytes"
+        rev = chain.from_iterable(reversed(i) for i in reversed(data))
+        for index, (i, k) in enumerate(zip(rev, reversed(suffix))):
+            if i != k:
+                return len(suffix) - index
+        return 0
+
+    #
+    # Protection
+    #
+
+    def __hash__(self) -> int:
+        return hash((self.__class__, self.f))
+
+    __deepcopy__ = None  # type: ignore
+    __copy__ = None  # type: ignore
+
+
+def _mode(f: IOBase, binary: bool | None) -> bool:
+    mode = getattr(f, "mode", "")
+    binary = binary or "b" in mode or isinstance(f, (_PyRawIOBase, _PyBufferedIOBase))
+    text = (binary is False) or (mode and "b" not in mode) or isinstance(f, _PyRawTextIOBase)
+    if not text and not binary:
+        raise TypeError("Cannot determine if IO object is text or binary")
+    if text and binary:
+        raise TypeError("IO object is both text and binary")
+    return text
+
+
+class TextIO(_IOWrapperBase[str]):
+    """
+    A wrapper around TextIO objects that add additional functionality such as readuntil, unread, and peek
+    """
+
+    def __new__(cls, f: IOBase):
+        if not _mode(f, binary=False):
+            raise TypeError("raw should be a non-binary IO object")
+        return super().__new__(cls, f, binary=False)
+
+    def __init__(self, f: IOBase):
+        super().__init__(f, binary=False)
+
+
+class BinaryIO(_IOWrapperBase[bytes]):
+    """
+    A wrapper around BinaryIO objects that add additional functionality such as readuntil, unread, and peek
+    """
+
+    def __new__(cls, f: IOBase):
+        if _mode(f, binary=True):
+            raise TypeError("raw should be a binary IO object")
+        return super().__new__(cls, f, binary=True)
+
+    def __init__(self, f: IOBase):
+        super().__init__(f, binary=False)
+
+
+def io(raw: IOBase, binary: bool | None = None) -> TextIO | BinaryIO:
+    """
+    Convert an IO object to a TextIO or BinaryIO object
+        For raw to be valid, one of the three must be true:
+        1. raw is an io.TextIOBase, io.RawIOBase, or io.BufferedIOBase object
+        2. raw has a .mode string attribute
+        3. binary must be set
+    If the three detection methods disagree on if raw is binary, a TypeError is raised
+    """
+    return TextIO(raw) if _mode(raw, binary) else BinaryIO(raw)

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/log/cute.py

@@ -16,17 +16,25 @@ class CuteFormatter(Formatter):
     A log formatter that can print log messages with colors.
     """
 
-    DEFAULT_CUTE_WIDTHS = {"cute_levelname": 8, "cute_time": 23, "cute_name": 12}
-    __slots__ = ("colored", "_color", "_cmap", "_name_width")
+    __slots__ = ("colored", "_color", "_cmap", "_lvl_cmap", "_dim_level", "_name_width")
+    DEFAULT_CUTE_WIDTHS: dict[str, int] = {"cute_levelname": 8, "cute_time": 23, "cute_name": 12}
+    DEFAULT_LEVEL_COLORS: dict[int, Color] = {
+        INFO: Color.blue,
+        WARNING: Color.yellow,
+        ERROR: Color.red,
+        CRITICAL: Color.bright_red_bg_yellow,
+    }
 
-    # pylint: disable=dangerous-default-value
+    # pylint: disable=dangerous-default-value,keyword-arg-before-vararg,too-many-arguments
     def __init__(
         self,
-        colors: dict[str, Color] | None = None,
-        *,
+        fmt="%(cute_levelname)s | %(cute_asctime)s | %(cute_name)s | %(cute_message)s",
+        *args,
         colored: bool = True,
+        dim_level: int = DEBUG,
+        colors: dict[str, Color] = {},
+        level_colors: dict[int, Color] = {},
         cute_widths: dict[str, int] = {},
-        fmt="%(cute_levelname)s | %(cute_asctime)s | %(cute_name)s | %(cute_message)s",
         **kwargs,
     ):
         """
@@ -34,16 +42,20 @@ class CuteFormatter(Formatter):
         Do not modify cute_ parameters in the fmt string; they might have special formatting that is not visible
         Ex. %(cute_name)-8s should be done via cute_widths["cute_name"] = 8
         This is because cute_widths takes into account 0-width color codes when padding
-        :param colors: The colors to use for the given loggers, automatic for non-specified loggers
-        :param colored: If False, no colors will be used regardless of the colors parameter
+        Level colors used are: DEFAULT_LEVEL_COLORS | level_colors
+        Dimming of log messages is done for levels < dim_level
         :param fmt: The format string to use for the log message; do not modify cute_ parameters
+        :param args: Passed to logging.Formatter
+        :param colored: If False, no colors will be used regardless of the colors parameter
+        :param colors: The colors to use for the given loggers, automatic for non-specified loggers
+        :param level_colors: The colors to use >= the given levels, automatic for non-specified loggers
         :param cute_widths: The widths of the cute_ columns in the log message
         :param kwargs: Passed to logging.Formatter
         """
-        super().__init__(fmt=fmt, **kwargs)
-        self._cmap: dict[str, Color] = {}
-        if colors is not None:
-            self.update(colors)
+        super().__init__(fmt, *args, **kwargs)
+        self._dim_level: int = dim_level
+        self._cmap: dict[str, Color] = dict(colors)
+        self._lvl_cmap: dict[int, Color] = self.DEFAULT_LEVEL_COLORS | level_colors
         self._widths = defaultdict(int, self.DEFAULT_CUTE_WIDTHS | cute_widths)
         if any(not i.startswith("cute_") for i in self._widths):
             raise ValueError("cute_widths must only contain cute_ parameters")
@@ -53,7 +65,7 @@ class CuteFormatter(Formatter):
         """
         Set the colors for all loggers; enables colors if disabled
         """
-        self._cmap.update(colors)
+        self._cmap |= colors
 
     def format(self, record: LogRecord) -> str:
         levelname: str = record.levelname.ljust(self._widths["cute_levelname"])
@@ -62,26 +74,22 @@ class CuteFormatter(Formatter):
         message: str = record.getMessage().ljust(self._widths["cute_message"])
         if self.colored:
             # Color level
-            if record.levelno >= CRITICAL:
-                levelname = Color.bright_red_bg_yellow(levelname)
-            elif record.levelno >= ERROR:
-                levelname = Color.red(levelname)
-            elif record.levelno >= WARNING:
-                levelname = Color.yellow(levelname)
-            elif record.levelno >= INFO:
-                levelname = Color.blue(levelname)
-            elif record.levelno < DEBUG:
-                levelname = Color.dim(levelname)
+            opts = tuple(i for i in self._lvl_cmap if i <= record.levelno)
+            col: Color | None = self._lvl_cmap[max(opts)] if opts else None
+            if record.levelno < self._dim_level:
+                col = Color.dim if col is None else (col + Color.dim)
+            if col is not None:
+                levelname = col(levelname)
             # Color text
             if (col := self._cmap.get(record.name, None)) is None:
                 c: int = adler32(record.name.encode()) % 7
                 col = Color(RawColor(PureColor.black.value + c)) if c != 0 else Color.default
-            if record.levelno < DEBUG:
+            if record.levelno < self._dim_level:
                 col += Color.dim
             message = col(message)
             name = col(name)
             # Color timestamp
-            if record.levelno < DEBUG:
+            if record.levelno < self._dim_level:
                 asctime = Color.dim(asctime)
         # Create an updated record then format that
         new = copy(record)

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/log/trace.py

@@ -3,13 +3,11 @@ import logging
 
 
 class _State:
+    __init__ = None  # type: ignore
     start: bool = False
     ready: bool = False
     lock = Lock()
 
-    def __init__(self):
-        raise NotImplementedError()
-
 
 def install(*, value=logging.DEBUG // 2, force: bool = False) -> None:
     """

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib/singleton.py

@@ -19,13 +19,13 @@ class SingletonType(type):
         Intercept all class definitions to prevent subclassing singleton types except for Singleton
         """
         if "__init_subclass__" in attrs:
-            raise NotImplementedError("Singleton's should not be subclassed or implement __init_subclass__")
+            raise TypeError("Singleton's should not be subclassed or implement __init_subclass__")
 
         def _init_subclass(cls):
             with mcs._types_lock:
                 if any(issubclass(cls, i) for i in mcs._types if i is not Singleton):
                     err = "Do not derive from Singletons other than the base Singleton type"
-                    raise NotImplementedError(err)
+                    raise TypeError(err)
                 mcs._types.append(cls)
 
         attrs["__init_subclass__"] = _init_subclass

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib.egg-info/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: zstdlib
-Version: 0.0.7
+Version: 0.0.11
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib
 Keywords: remote,pipe
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 

{zstdlib-0.0.7 → zstdlib-0.0.11}/zstdlib.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ tests/not_set.py
 tests/test_ansi.py
 tests/test_enum.py
 tests/test_frozen.py
+tests/test_io.py
 tests/test_singleton.py
 tests/log/__init__.py
 tests/log/base.py
@@ -15,6 +16,7 @@ zstdlib/__init__.py
 zstdlib/ansi.py
 zstdlib/enum.py
 zstdlib/frozen.py
+zstdlib/io.py
 zstdlib/not_set.py
 zstdlib/py.typed
 zstdlib/singleton.py