libvalkey 3.0.0__tar.gz

libvalkey-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2023, the maintainers of this library.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libvalkey-3.0.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include LICENSE
+include MANIFEST.in
+include README.md
+include src/*.[ch]
+include vendor/libvalkey/COPYING
+include vendor/libvalkey/src/*.[ch]
+graft tests
+global-exclude __pycache__
+global-exclude *.py[co]

libvalkey-3.0.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.1
+Name: libvalkey
+Version: 3.0.0
+Summary: Python wrapper for libvalkey
+Home-page: https://github.com/valkey-io/libvalkey-py
+Author: libvalkey-py authors
+Author-email: libvalkey-py@lists.valkey.io
+License: MIT
+Project-URL: Changes, https://github.com/valkey-io/libvalkey-py/releases
+Project-URL: Issue tracker, https://github.com/valkey-io/libvalkey-py/issues
+Keywords: Valkey
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# libvalkey-py
+
+[![Build Status](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml/badge.svg)](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![pypi](https://badge.fury.io/py/libvalkey.svg)](https://pypi.org/project/libvalkey/)
+
+Python extension that wraps protocol parsing code in [libvalkey][libvalkey].
+It primarily speeds up parsing of multi bulk replies.
+
+[libvalkey]: http://github.com/valkey-io/libvalkey
+
+## Install
+
+libvalkey-py is available on [PyPI](https://pypi.org/project/libvalkey/), and can be installed via:
+
+```bash
+pip install libvalkey
+```
+## Building and Testing
+
+Building this repository requires a recursive checkout of submodules, and building libvalkey. The following example shows how to clone, compile, and run tests. Please note - you will need the gcc installed.
+
+```bash
+git clone --recurse-submodules https://github.com/valkey-io/libvalkey-py
+python setup.py build_ext --inplace
+python -m pytest
+```
+
+### Requirements
+
+libvalkey-py requires **Python 3.8+**.
+
+Make sure Python development headers are available when installing libvalkey-py.
+On Ubuntu/Debian systems, install them with `apt-get install python3-dev`.
+
+## Usage
+
+The `libvalkey` module contains the `Reader` class. This class is responsible for
+parsing replies from the stream of data that is read from a Redis connection.
+It does not contain functionality to handle I/O.
+
+### Reply parser
+
+The `Reader` class has two methods that are used when parsing replies from a
+stream of data. `Reader.feed` takes a string argument that is appended to the
+internal buffer. `Reader.gets` reads this buffer and returns a reply when the
+buffer contains a full reply. If a single call to `feed` contains multiple
+replies, `gets` should be called multiple times to extract all replies.
+
+Example:
+
+```python
+>>> reader = libvalkey.Reader()
+>>> reader.feed("$5\r\nhello\r\n")
+>>> reader.gets()
+b'hello'
+```
+
+When the buffer does not contain a full reply, `gets` returns `False`.
+This means extra data is needed and `feed` should be called again before calling
+`gets` again. Alternatively you could provide custom sentinel object via parameter,
+which is useful for RESP3 protocol where native boolean types are supported:
+
+Example:
+
+```python
+>>> reader.feed("*2\r\n$5\r\nhello\r\n")
+>>> reader.gets()
+False
+>>> reader.feed("$5\r\nworld\r\n")
+>>> reader.gets()
+[b'hello', b'world']
+>>> reader = libvalkey.Reader(notEnoughData=Ellipsis)
+>>> reader.gets()
+Ellipsis
+```
+
+#### Unicode
+
+`libvalkey.Reader` is able to decode bulk data to any encoding Python supports.
+To do so, specify the encoding you want to use for decoding replies when
+initializing it:
+
+```python
+>>> reader = libvalkey.Reader(encoding="utf-8", errors="strict")
+>>> reader.feed(b"$3\r\n\xe2\x98\x83\r\n")
+>>> reader.gets()
+'☃'
+```
+
+Decoding of bulk data will be attempted using the specified encoding and
+error handler. If the error handler is `'strict'` (the default), a
+`UnicodeDecodeError` is raised when data cannot be dedcoded. This is identical
+to Python's default behavior. Other valid values to `errors` include
+`'replace'`, `'ignore'`, and `'backslashreplace'`. More information on the
+behavior of these error handlers can be found
+[here](https://docs.python.org/3/howto/unicode.html#the-string-type).
+
+
+When the specified encoding cannot be found, a `LookupError` will be raised
+when calling `gets` for the first reply with bulk data.
+
+#### Error handling
+
+When a protocol error occurs (because of multiple threads using the same
+socket, or some other condition that causes a corrupt stream), the error
+`libvalkey.ProtocolError` is raised. Because the buffer is read in a lazy
+fashion, it will only be raised when `gets` is called and the first reply in
+the buffer contains an error. There is no way to recover from a faulty protocol
+state, so when this happens, the I/O code feeding data to `Reader` should
+probably reconnect.
+
+The server can reply with error replies (`-ERR ...`). For these replies, the
+custom error class `libvalkey.ReplyError` is returned, **but not raised**.
+
+When other error types should be used (so existing code doesn't have to change
+its `except` clauses), `Reader` can be initialized with the `protocolError` and
+`replyError` keywords. These keywords should contain a *class* that is a
+subclass of `Exception`. When not provided, `Reader` will use the default
+error types.
+
+## Benchmarks
+
+The repository contains a benchmarking script in the `benchmark` directory,
+which uses [gevent](http://gevent.org/) to have non-blocking I/O and valkey-py
+to handle connections. These benchmarks are done with a patched version of
+valkey-py that uses libvalkey-py when it is available.
+
+All benchmarks are done with 10 concurrent connections.
+
+* SET key value + GET key
+  * valkey-py: 11.76 Kops
+  * valkey-py *with* libvalkey-py: 13.40 Kops
+  * improvement: **1.1x**
+
+List entries in the following tests are 5 bytes.
+
+* LRANGE list 0 **9**:
+  * valkey-py: 4.78 Kops
+  * valkey-py *with* libvalkey-py: 12.94 Kops
+  * improvement: **2.7x**
+* LRANGE list 0 **99**:
+  * valkey-py: 0.73 Kops
+  * valkey-py *with* libvalkey-py: 11.90 Kops
+  * improvement: **16.3x**
+* LRANGE list 0 **999**:
+  * valkey-py: 0.07 Kops
+  * valkey-py *with* libvalkey-py: 5.83 Kops
+  * improvement: **83.2x**
+
+Throughput improvement for simple SET/GET is minimal, but the larger multi bulk replies
+get, the larger the performance improvement is.
+
+## License
+
+This code is released under the BSD license, as the license of hiredis-py at
+the time of fork.

libvalkey-3.0.0/README.md

@@ -0,0 +1,157 @@
+# libvalkey-py
+
+[![Build Status](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml/badge.svg)](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![pypi](https://badge.fury.io/py/libvalkey.svg)](https://pypi.org/project/libvalkey/)
+
+Python extension that wraps protocol parsing code in [libvalkey][libvalkey].
+It primarily speeds up parsing of multi bulk replies.
+
+[libvalkey]: http://github.com/valkey-io/libvalkey
+
+## Install
+
+libvalkey-py is available on [PyPI](https://pypi.org/project/libvalkey/), and can be installed via:
+
+```bash
+pip install libvalkey
+```
+## Building and Testing
+
+Building this repository requires a recursive checkout of submodules, and building libvalkey. The following example shows how to clone, compile, and run tests. Please note - you will need the gcc installed.
+
+```bash
+git clone --recurse-submodules https://github.com/valkey-io/libvalkey-py
+python setup.py build_ext --inplace
+python -m pytest
+```
+
+### Requirements
+
+libvalkey-py requires **Python 3.8+**.
+
+Make sure Python development headers are available when installing libvalkey-py.
+On Ubuntu/Debian systems, install them with `apt-get install python3-dev`.
+
+## Usage
+
+The `libvalkey` module contains the `Reader` class. This class is responsible for
+parsing replies from the stream of data that is read from a Redis connection.
+It does not contain functionality to handle I/O.
+
+### Reply parser
+
+The `Reader` class has two methods that are used when parsing replies from a
+stream of data. `Reader.feed` takes a string argument that is appended to the
+internal buffer. `Reader.gets` reads this buffer and returns a reply when the
+buffer contains a full reply. If a single call to `feed` contains multiple
+replies, `gets` should be called multiple times to extract all replies.
+
+Example:
+
+```python
+>>> reader = libvalkey.Reader()
+>>> reader.feed("$5\r\nhello\r\n")
+>>> reader.gets()
+b'hello'
+```
+
+When the buffer does not contain a full reply, `gets` returns `False`.
+This means extra data is needed and `feed` should be called again before calling
+`gets` again. Alternatively you could provide custom sentinel object via parameter,
+which is useful for RESP3 protocol where native boolean types are supported:
+
+Example:
+
+```python
+>>> reader.feed("*2\r\n$5\r\nhello\r\n")
+>>> reader.gets()
+False
+>>> reader.feed("$5\r\nworld\r\n")
+>>> reader.gets()
+[b'hello', b'world']
+>>> reader = libvalkey.Reader(notEnoughData=Ellipsis)
+>>> reader.gets()
+Ellipsis
+```
+
+#### Unicode
+
+`libvalkey.Reader` is able to decode bulk data to any encoding Python supports.
+To do so, specify the encoding you want to use for decoding replies when
+initializing it:
+
+```python
+>>> reader = libvalkey.Reader(encoding="utf-8", errors="strict")
+>>> reader.feed(b"$3\r\n\xe2\x98\x83\r\n")
+>>> reader.gets()
+'☃'
+```
+
+Decoding of bulk data will be attempted using the specified encoding and
+error handler. If the error handler is `'strict'` (the default), a
+`UnicodeDecodeError` is raised when data cannot be dedcoded. This is identical
+to Python's default behavior. Other valid values to `errors` include
+`'replace'`, `'ignore'`, and `'backslashreplace'`. More information on the
+behavior of these error handlers can be found
+[here](https://docs.python.org/3/howto/unicode.html#the-string-type).
+
+
+When the specified encoding cannot be found, a `LookupError` will be raised
+when calling `gets` for the first reply with bulk data.
+
+#### Error handling
+
+When a protocol error occurs (because of multiple threads using the same
+socket, or some other condition that causes a corrupt stream), the error
+`libvalkey.ProtocolError` is raised. Because the buffer is read in a lazy
+fashion, it will only be raised when `gets` is called and the first reply in
+the buffer contains an error. There is no way to recover from a faulty protocol
+state, so when this happens, the I/O code feeding data to `Reader` should
+probably reconnect.
+
+The server can reply with error replies (`-ERR ...`). For these replies, the
+custom error class `libvalkey.ReplyError` is returned, **but not raised**.
+
+When other error types should be used (so existing code doesn't have to change
+its `except` clauses), `Reader` can be initialized with the `protocolError` and
+`replyError` keywords. These keywords should contain a *class* that is a
+subclass of `Exception`. When not provided, `Reader` will use the default
+error types.
+
+## Benchmarks
+
+The repository contains a benchmarking script in the `benchmark` directory,
+which uses [gevent](http://gevent.org/) to have non-blocking I/O and valkey-py
+to handle connections. These benchmarks are done with a patched version of
+valkey-py that uses libvalkey-py when it is available.
+
+All benchmarks are done with 10 concurrent connections.
+
+* SET key value + GET key
+  * valkey-py: 11.76 Kops
+  * valkey-py *with* libvalkey-py: 13.40 Kops
+  * improvement: **1.1x**
+
+List entries in the following tests are 5 bytes.
+
+* LRANGE list 0 **9**:
+  * valkey-py: 4.78 Kops
+  * valkey-py *with* libvalkey-py: 12.94 Kops
+  * improvement: **2.7x**
+* LRANGE list 0 **99**:
+  * valkey-py: 0.73 Kops
+  * valkey-py *with* libvalkey-py: 11.90 Kops
+  * improvement: **16.3x**
+* LRANGE list 0 **999**:
+  * valkey-py: 0.07 Kops
+  * valkey-py *with* libvalkey-py: 5.83 Kops
+  * improvement: **83.2x**
+
+Throughput improvement for simple SET/GET is minimal, but the larger multi bulk replies
+get, the larger the performance improvement is.
+
+## License
+
+This code is released under the BSD license, as the license of hiredis-py at
+the time of fork.

libvalkey-3.0.0/libvalkey/__init__.py

@@ -0,0 +1,10 @@
+from libvalkey.libvalkey import Reader, LibvalkeyError, pack_command, ProtocolError, ReplyError
+from libvalkey.version import __version__
+
+__all__ = [
+  "Reader",
+  "LibvalkeyError",
+  "pack_command",
+  "ProtocolError",
+  "ReplyError",
+  "__version__"]

libvalkey-3.0.0/libvalkey/libvalkey.pyi

@@ -0,0 +1,41 @@
+from typing import Any, Callable, Optional, Union, Tuple
+
+
+class LibvalkeyError(Exception):
+    ...
+
+
+class ProtocolError(LibvalkeyError):
+    ...
+
+
+class ReplyError(LibvalkeyError):
+    ...
+
+
+class Reader:
+    def __init__(
+        self,
+        protocolError: Callable[[str], Exception] = ...,
+        replyError: Callable[[str], Exception] = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        notEnoughData: Any = ...,
+        listOnly: bool = ...,
+    ) -> None: ...
+
+    def feed(
+        self, __buf: Union[str, bytes], __off: int = ..., __len: int = ...
+    ) -> None: ...
+    def gets(self, __shouldDecode: bool = ...) -> Any: ...
+    def setmaxbuf(self, __maxbuf: Optional[int]) -> None: ...
+    def getmaxbuf(self) -> int: ...
+    def len(self) -> int: ...
+    def has_data(self) -> bool: ...
+
+    def set_encoding(
+        self, encoding: Optional[str] = ..., errors: Optional[str] = ...
+    ) -> None: ...
+
+
+def pack_command(cmd: Tuple[str | int | float | bytes | memoryview]): ...

libvalkey-3.0.0/libvalkey/version.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

libvalkey-3.0.0/libvalkey.egg-info/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.1
+Name: libvalkey
+Version: 3.0.0
+Summary: Python wrapper for libvalkey
+Home-page: https://github.com/valkey-io/libvalkey-py
+Author: libvalkey-py authors
+Author-email: libvalkey-py@lists.valkey.io
+License: MIT
+Project-URL: Changes, https://github.com/valkey-io/libvalkey-py/releases
+Project-URL: Issue tracker, https://github.com/valkey-io/libvalkey-py/issues
+Keywords: Valkey
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# libvalkey-py
+
+[![Build Status](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml/badge.svg)](https://github.com/valkey-io/libvalkey-py/actions/workflows/integration.yaml)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![pypi](https://badge.fury.io/py/libvalkey.svg)](https://pypi.org/project/libvalkey/)
+
+Python extension that wraps protocol parsing code in [libvalkey][libvalkey].
+It primarily speeds up parsing of multi bulk replies.
+
+[libvalkey]: http://github.com/valkey-io/libvalkey
+
+## Install
+
+libvalkey-py is available on [PyPI](https://pypi.org/project/libvalkey/), and can be installed via:
+
+```bash
+pip install libvalkey
+```
+## Building and Testing
+
+Building this repository requires a recursive checkout of submodules, and building libvalkey. The following example shows how to clone, compile, and run tests. Please note - you will need the gcc installed.
+
+```bash
+git clone --recurse-submodules https://github.com/valkey-io/libvalkey-py
+python setup.py build_ext --inplace
+python -m pytest
+```
+
+### Requirements
+
+libvalkey-py requires **Python 3.8+**.
+
+Make sure Python development headers are available when installing libvalkey-py.
+On Ubuntu/Debian systems, install them with `apt-get install python3-dev`.
+
+## Usage
+
+The `libvalkey` module contains the `Reader` class. This class is responsible for
+parsing replies from the stream of data that is read from a Redis connection.
+It does not contain functionality to handle I/O.
+
+### Reply parser
+
+The `Reader` class has two methods that are used when parsing replies from a
+stream of data. `Reader.feed` takes a string argument that is appended to the
+internal buffer. `Reader.gets` reads this buffer and returns a reply when the
+buffer contains a full reply. If a single call to `feed` contains multiple
+replies, `gets` should be called multiple times to extract all replies.
+
+Example:
+
+```python
+>>> reader = libvalkey.Reader()
+>>> reader.feed("$5\r\nhello\r\n")
+>>> reader.gets()
+b'hello'
+```
+
+When the buffer does not contain a full reply, `gets` returns `False`.
+This means extra data is needed and `feed` should be called again before calling
+`gets` again. Alternatively you could provide custom sentinel object via parameter,
+which is useful for RESP3 protocol where native boolean types are supported:
+
+Example:
+
+```python
+>>> reader.feed("*2\r\n$5\r\nhello\r\n")
+>>> reader.gets()
+False
+>>> reader.feed("$5\r\nworld\r\n")
+>>> reader.gets()
+[b'hello', b'world']
+>>> reader = libvalkey.Reader(notEnoughData=Ellipsis)
+>>> reader.gets()
+Ellipsis
+```
+
+#### Unicode
+
+`libvalkey.Reader` is able to decode bulk data to any encoding Python supports.
+To do so, specify the encoding you want to use for decoding replies when
+initializing it:
+
+```python
+>>> reader = libvalkey.Reader(encoding="utf-8", errors="strict")
+>>> reader.feed(b"$3\r\n\xe2\x98\x83\r\n")
+>>> reader.gets()
+'☃'
+```
+
+Decoding of bulk data will be attempted using the specified encoding and
+error handler. If the error handler is `'strict'` (the default), a
+`UnicodeDecodeError` is raised when data cannot be dedcoded. This is identical
+to Python's default behavior. Other valid values to `errors` include
+`'replace'`, `'ignore'`, and `'backslashreplace'`. More information on the
+behavior of these error handlers can be found
+[here](https://docs.python.org/3/howto/unicode.html#the-string-type).
+
+
+When the specified encoding cannot be found, a `LookupError` will be raised
+when calling `gets` for the first reply with bulk data.
+
+#### Error handling
+
+When a protocol error occurs (because of multiple threads using the same
+socket, or some other condition that causes a corrupt stream), the error
+`libvalkey.ProtocolError` is raised. Because the buffer is read in a lazy
+fashion, it will only be raised when `gets` is called and the first reply in
+the buffer contains an error. There is no way to recover from a faulty protocol
+state, so when this happens, the I/O code feeding data to `Reader` should
+probably reconnect.
+
+The server can reply with error replies (`-ERR ...`). For these replies, the
+custom error class `libvalkey.ReplyError` is returned, **but not raised**.
+
+When other error types should be used (so existing code doesn't have to change
+its `except` clauses), `Reader` can be initialized with the `protocolError` and
+`replyError` keywords. These keywords should contain a *class* that is a
+subclass of `Exception`. When not provided, `Reader` will use the default
+error types.
+
+## Benchmarks
+
+The repository contains a benchmarking script in the `benchmark` directory,
+which uses [gevent](http://gevent.org/) to have non-blocking I/O and valkey-py
+to handle connections. These benchmarks are done with a patched version of
+valkey-py that uses libvalkey-py when it is available.
+
+All benchmarks are done with 10 concurrent connections.
+
+* SET key value + GET key
+  * valkey-py: 11.76 Kops
+  * valkey-py *with* libvalkey-py: 13.40 Kops
+  * improvement: **1.1x**
+
+List entries in the following tests are 5 bytes.
+
+* LRANGE list 0 **9**:
+  * valkey-py: 4.78 Kops
+  * valkey-py *with* libvalkey-py: 12.94 Kops
+  * improvement: **2.7x**
+* LRANGE list 0 **99**:
+  * valkey-py: 0.73 Kops
+  * valkey-py *with* libvalkey-py: 11.90 Kops
+  * improvement: **16.3x**
+* LRANGE list 0 **999**:
+  * valkey-py: 0.07 Kops
+  * valkey-py *with* libvalkey-py: 5.83 Kops
+  * improvement: **83.2x**
+
+Throughput improvement for simple SET/GET is minimal, but the larger multi bulk replies
+get, the larger the performance improvement is.
+
+## License
+
+This code is released under the BSD license, as the license of hiredis-py at
+the time of fork.

libvalkey-3.0.0/libvalkey.egg-info/SOURCES.txt

@@ -0,0 +1,46 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.cfg
+setup.py
+libvalkey/__init__.py
+libvalkey/libvalkey.pyi
+libvalkey/py.typed
+libvalkey/version.py
+libvalkey.egg-info/PKG-INFO
+libvalkey.egg-info/SOURCES.txt
+libvalkey.egg-info/dependency_links.txt
+libvalkey.egg-info/top_level.txt
+src/libvalkey.c
+src/libvalkey.h
+src/pack.c
+src/pack.h
+src/reader.c
+src/reader.h
+tests/test_gc.py
+tests/test_pack.py
+tests/test_reader.py
+vendor/libvalkey/src/adlist.c
+vendor/libvalkey/src/adlist.h
+vendor/libvalkey/src/alloc.c
+vendor/libvalkey/src/async.c
+vendor/libvalkey/src/async_private.h
+vendor/libvalkey/src/cmddef.h
+vendor/libvalkey/src/command.c
+vendor/libvalkey/src/command.h
+vendor/libvalkey/src/crc16.c
+vendor/libvalkey/src/dict.c
+vendor/libvalkey/src/fmacros.h
+vendor/libvalkey/src/net.c
+vendor/libvalkey/src/read.c
+vendor/libvalkey/src/sds.c
+vendor/libvalkey/src/sdsalloc.h
+vendor/libvalkey/src/sockcompat.c
+vendor/libvalkey/src/ssl.c
+vendor/libvalkey/src/valkey.c
+vendor/libvalkey/src/valkey_private.h
+vendor/libvalkey/src/valkeycluster.c
+vendor/libvalkey/src/valkeycluster_ssl.c
+vendor/libvalkey/src/vkutil.c
+vendor/libvalkey/src/vkutil.h
+vendor/libvalkey/src/win32.h

libvalkey-3.0.0/libvalkey.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libvalkey-3.0.0/libvalkey.egg-info/top_level.txt

@@ -0,0 +1 @@
+libvalkey

libvalkey-3.0.0/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description_file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+