simple-socket-client 1.4__tar.gz → 2.0__tar.gz

simple_socket_client-2.0/CHANGELOG.md

@@ -0,0 +1,105 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0] - 2026-11-15
+
+### Added
+
+- `message(data)` event for data the server sends on its own. The previous
+  version read the socket only inside `ask()`, so unsolicited bytes stayed in the
+  kernel buffer and eventually stalled the connection.
+- `error(error)` event for a socket error; the connection is closed right after
+  and `disconnect` follows.
+- `is_connected`, `host` and `port` properties.
+- `simple_socket_client.__version__`, an explicit `__all__` and type hints on
+  every public name, so mypy and pyright see real signatures instead of `Any`.
+  The `py.typed` marker (PEP 561) is shipped with the package.
+- `tests/`: pytest suite covering the lifecycle, the message flow through both
+  `message` and `ask()`, large payloads, concurrent senders, graceful and abrupt
+  disconnects, errors and reconnects.
+- GitHub Actions workflows: tests on Python 3.9-3.15 and 3.13t, plus a tag-driven
+  release pipeline publishing to PyPI and creating a GitHub Release.
+- `CHANGELOG.md` and `.gitattributes` with `* text=auto eol=lf`.
+
+### Fixed
+
+- The serving thread spun at 100% of a CPU core: the loop polled the send queue
+  with `get_nowait()` and `continue`. It waits in `select()` now, and the poll
+  interval is the only timeout.
+- `connect()` spun as well and hung forever when the connection failed with
+  anything but `SimpleSocketClientException`: the exception was lost in the
+  worker thread and the `connected` flag never changed.
+- A connection timeout was not reported on Python 3.9: `socket.timeout` is not
+  the builtin `TimeoutError` before 3.10, so the error escaped unwrapped.
+- `disconnect()` only raised a flag: the socket was closed on the next loop
+  iteration, the messages already queued by `send()` could be dropped, and
+  nothing waited for the close. It stops reading, delivers the queue, closes the
+  socket and then emits the event.
+- `ask()` shared one `__keep_answer` flag between all callers, so two overlapping
+  calls broke each other; every call waits for its own chunk now.
+- `send()` accepted bytes for a connection that was already gone and put them
+  into a queue nobody read.
+- A connection reset was not reported: a `recv()` error ended the loop silently.
+- The serving thread blocked in `recv()`, so a silent server could not be
+  disconnected and a forgotten `disconnect()` never let the interpreter exit.
+  The socket is non-blocking and polled, and the thread is a daemon.
+- `__disconnected()`, `__incoming_messages` and the two-argument
+  `__threading()` helper are gone: the loops they belonged to could not report
+  their state, and the first two were never called.
+
+### Changed
+
+- `send()` is safe to call from another thread: the queue and the poll state are
+  guarded by a lock. A message larger than the socket buffer is delivered in
+  full, because the unwritten tail is retried on the next poll.
+- `ask()` returns the first chunk of data, raises `TimeoutError` when nothing
+  comes within the timeout and `SimpleSocketClientException` when the connection
+  is closed while waiting. The same chunk is emitted as a `message` event.
+- A server that closed its end of the connection keeps receiving the messages
+  already queued, the way a half-closed connection can still be written to.
+- Packaging moved from `setup.py` to `pyproject.toml` (PEP 621, PEP 639);
+  metadata, build configuration and pytest settings live in one file, and
+  `requirements.txt` is gone.
+- Documentation: README rewritten with the event table, the API table, and the
+  framing, threading and compatibility notes.
+
+### Breaking
+
+- The `connect` and `disconnect` handlers receive `host` and `port` as two
+  arguments instead of one `(host, port)` tuple.
+- Python 3.9 or newer is required.
+- `SimpleSocketClientException` wraps the underlying `OSError` (`raise ... from`).
+- `connect()` raises `RuntimeError` for a live connection instead of starting a
+  second one.
+- The serving thread is a daemon: a forgotten `disconnect()` no longer keeps the
+  interpreter alive, so call it when the queued messages must be delivered.
+
+## [1.5] - 2023-03-03
+
+- Connection timeout, and the exception of the worker thread is passed to the
+  caller of `connect()`.
+
+## [1.4] - 2023-02-06
+
+- `EventBus.__init__` is called from the client constructor.
+
+## [1.3] - 2023-02-06
+
+- Replaced the bundled event emitter with the `event-bus` library.
+
+## [1.2] - 2023-02-04
+
+- Fixed a typo.
+
+## [1.1] - 2023-02-04
+
+- Dependencies declared in `setup.py`.
+
+## [1.0] - 2023-02-04
+
+- First published release: TCP client with `connect`, `send()`, `ask()` and
+  `disconnect()`.

{simple-socket-client-1.4 → simple_socket_client-2.0}/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2023, Alexey Kuznetsov
+Copyright (c) 2023–2026, webtoucher
 
 All rights reserved.
 

simple_socket_client-2.0/MANIFEST.in

@@ -0,0 +1 @@
+include CHANGELOG.md

simple_socket_client-2.0/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: simple-socket-client
+Version: 2.0
+Summary: Simple TCP socket client with select
+Author-email: Alexey Kuznetsov <mirakuru@webtoucher.ru>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/webtoucher/simple-socket-client
+Project-URL: Repository, https://github.com/webtoucher/simple-socket-client
+Project-URL: Issues, https://github.com/webtoucher/simple-socket-client/issues
+Project-URL: Changelog, https://github.com/webtoucher/simple-socket-client/blob/master/CHANGELOG.md
+Keywords: socket,tcp,client,networking,event-driven
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Networking
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: event-bus~=1.0.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# Simple TCP socket client with select
+
+![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
+[![Downloads](https://img.shields.io/pypi/dm/simple-socket-client.svg?color=orange)](https://pypi.python.org/pypi/simple-socket-client)
+[![Latest Version](https://img.shields.io/pypi/v/simple-socket-client.svg)](https://pypi.python.org/pypi/simple-socket-client)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/simple-socket-client.svg)](https://pypi.python.org/pypi/simple-socket-client)
+[![tests](https://github.com/webtoucher/simple-socket-client/actions/workflows/tests.yml/badge.svg)](https://github.com/webtoucher/simple-socket-client/actions/workflows/tests.yml)
+
+A TCP client that keeps one connection in a background thread on a `select()` poll
+with no networking framework underneath: you subscribe handlers to events and the
+client calls them. Type hints are shipped with the package, the only runtime
+dependency is the event bus that dispatches those events.
+
+## Installation
+
+Install it with pip:
+
+```shell
+$ pip install simple-socket-client
+```
+
+Or you can add it as dependency in requirements.txt file of your python application:
+
+```
+simple-socket-client~=2.0
+```
+
+## Usage
+
+```python
+from simple_socket_client import SimpleSocketClient
+
+client = SimpleSocketClient('192.168.0.2', 6666)
+
+
+@client.on('message')
+def on_message(data: bytes):
+    print('Incoming data:', data)
+
+
+@client.on('disconnect')
+def on_disconnect(host, port):
+    print('Connection to %s:%s is closed' % (host, port))
+
+
+client.connect(timeout=10)
+
+client.send(b'Test')            # if you don't need an answer
+answer = client.ask(b'Hi!')
+print(answer.decode())
+
+client.disconnect()
+```
+
+`connect()` blocks the calling thread until the connection is established and
+raises `SimpleSocketClientException` when it fails, so there is no need to wait
+for the `connect` event to start using the client.
+
+`ask()` is a shorthand for "send and wait for the first chunk of the answer":
+
+```python
+answer = client.ask(b'PING\r\n', timeout=5)
+if answer == b'PONG\r\n':
+    print('the server is alive')
+```
+
+The same client works against [`simple-socket-server`](https://pypi.org/project/simple-socket-server/)
+and any other TCP server:
+
+```python
+from simple_socket_server import SimpleSocketServer
+
+server = SimpleSocketServer()
+
+
+@server.on('message')
+def on_message(sock, peer, data):
+    server.send(sock, b'Hi, ' + data)
+
+
+server.run(host='0.0.0.0', port=6666)
+```
+
+## Events
+
+Handlers are called one at a time from the thread that serves the connection;
+the `connect` handler is the exception, it is called by `connect()` itself.
+
+| Event        | Arguments       | When it fires                                                                 |
+|--------------|-----------------|-------------------------------------------------------------------------------|
+| `connect`    | `host, port`    | the connection is open                                                        |
+| `message`    | `data`          | a chunk of bytes has been received                                            |
+| `disconnect` | `host, port`    | the connection is closed; the messages queued by `send()` were delivered first |
+| `error`      | `error`         | a socket error occurred; the connection is closed and `disconnect` follows    |
+
+`data` is `bytes`, `error` is an `OSError`.
+
+## API
+
+| Member                                   | Description                                                           |
+|------------------------------------------|-----------------------------------------------------------------------|
+| `SimpleSocketClient(host, port)`         | a client for one address; nothing is opened until `connect()`         |
+| `connect(timeout=None)`                  | open the connection; blocks, `SimpleSocketClientException` on failure |
+| `disconnect()`                           | stop reading, deliver the queue, then close the connection            |
+| `send(message)`                          | queue `bytes` for the server                                          |
+| `ask(message, timeout=1.)`               | send `bytes` and return the first chunk of the answer                 |
+| `is_connected`                           | `True` while the connection is open and serving messages              |
+| `host`, `port`                           | the address the client connects to                                    |
+| `on(event)`, `emit(...)`                 | inherited from `event_bus.EventBus`                                   |
+
+Notes:
+
+- `connect()` raises `RuntimeError` for a live connection: one client object
+  serves one connection at a time. After `disconnect()` it can be called again,
+  and the queue of the previous connection is delivered first.
+- `send()` never blocks and never truncates: the socket is non-blocking, so the
+  bytes are buffered and the unwritten tail is retried on the next poll, so a
+  message larger than the socket buffer arrives in full.
+- `send()` and `disconnect()` are safe to call from another thread. Delivery
+  happens during the next poll, so it can take up to the poll interval (0.1 s).
+- `disconnect()` delivers the messages already queued, so a `send()` followed by
+  a `disconnect()` still reaches the server. From another thread the call waits
+  for that to finish, for up to 5 seconds: a server that stopped reading makes the
+  rest of the queue be dropped. From an event handler it only raises the flag and
+  the serving thread closes the socket itself.
+- **A handler must not raise.** The exception breaks the serving loop, the
+  connection is closed and `message` never arrives again; the exception itself is
+  printed by the `threading` module. Do the long work in your own thread and
+  handle per-message errors inside the handler.
+- `message` carries one raw `recv()` chunk of up to 1024 bytes. There is no
+  framing: the protocol you put on top has to delimit its own messages, and
+  `ask()` returns one chunk, which may hold more than the answer or less than a
+  full line.
+- `ask()` and a `message` handler see the same chunk. `ask()` raises
+  `TimeoutError` when nothing comes within the timeout and
+  `SimpleSocketClientException` when the connection is closed while waiting.
+- The serving thread is a daemon, so a forgotten `disconnect()` does not keep the
+  interpreter alive; the messages that were not written yet are lost then.
+- Do not call `sock.close()` yourself: the client owns the socket and drops it
+  with an `error` event of `select()` if it goes away behind its back.
+
+## Compatibility
+
+- Python **3.9 and newer**, including free-threaded builds: CI runs every version
+  from 3.9 to 3.15 plus the free-threaded `3.13t`.
+- One runtime dependency: [`event-bus`](https://pypi.org/project/event-bus/).
+- Type hints are shipped with the package (`py.typed`, PEP 561), so mypy and
+  pyright see real signatures instead of `Any`.
+- Any client instance is independent: several clients may serve several
+  connections in one process.
+
+## Development
+
+```shell
+$ python -m venv .venv
+$ .venv\Scripts\activate          # Windows; on POSIX: source .venv/bin/activate
+$ pip install -e ".[dev]"          # installs the package and pytest
+$ python -m pytest
+```
+
+The test suite covers:
+
+- the lifecycle: `connect`, `is_connected`, `host`, `port`, a rejected
+  connection, a second `connect()` on a live connection and a reconnect after a
+  graceful close,
+- the message flow: the `message` event for data the server sends on its own,
+  `ask()` round trips, `send()` ordering and a 256 KiB payload in both directions,
+- concurrency: several threads calling `send()` at once,
+- disconnects: the queue delivered before `disconnect()` closes the connection, an
+  idempotent `disconnect()`, a close and a reset by the server, and `ask()` that
+  waits when the connection goes away,
+- error handling: `send()` and `ask()` on a closed client, an empty message, an
+  `ask()` timeout, and a handler that raises,
+- the public API: `__all__`, the version and the package metadata.
+
+Project layout:
+
+```
+simple_socket_client/__init__.py  the whole library
+tests/                            test suite
+pyproject.toml                    metadata, build config and pytest settings
+.github/workflows/                CI: tests on Python 3.9-3.15 and 3.13t, release pipeline
+```
+
+To build and verify a release:
+
+```shell
+$ pip install build twine
+$ python -m build
+$ python -m twine check dist/*
+```
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md). GitHub Releases are generated from the matching
+entry of that file, so the history is available both in git and on the releases
+page.
+
+## License
+
+Distributed under the BSD 3-Clause license. See [LICENSE.md](LICENSE.md) for details.

simple_socket_client-2.0/README.md

@@ -0,0 +1,201 @@
+# Simple TCP socket client with select
+
+![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
+[![Downloads](https://img.shields.io/pypi/dm/simple-socket-client.svg?color=orange)](https://pypi.python.org/pypi/simple-socket-client)
+[![Latest Version](https://img.shields.io/pypi/v/simple-socket-client.svg)](https://pypi.python.org/pypi/simple-socket-client)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/simple-socket-client.svg)](https://pypi.python.org/pypi/simple-socket-client)
+[![tests](https://github.com/webtoucher/simple-socket-client/actions/workflows/tests.yml/badge.svg)](https://github.com/webtoucher/simple-socket-client/actions/workflows/tests.yml)
+
+A TCP client that keeps one connection in a background thread on a `select()` poll
+with no networking framework underneath: you subscribe handlers to events and the
+client calls them. Type hints are shipped with the package, the only runtime
+dependency is the event bus that dispatches those events.
+
+## Installation
+
+Install it with pip:
+
+```shell
+$ pip install simple-socket-client
+```
+
+Or you can add it as dependency in requirements.txt file of your python application:
+
+```
+simple-socket-client~=2.0
+```
+
+## Usage
+
+```python
+from simple_socket_client import SimpleSocketClient
+
+client = SimpleSocketClient('192.168.0.2', 6666)
+
+
+@client.on('message')
+def on_message(data: bytes):
+    print('Incoming data:', data)
+
+
+@client.on('disconnect')
+def on_disconnect(host, port):
+    print('Connection to %s:%s is closed' % (host, port))
+
+
+client.connect(timeout=10)
+
+client.send(b'Test')            # if you don't need an answer
+answer = client.ask(b'Hi!')
+print(answer.decode())
+
+client.disconnect()
+```
+
+`connect()` blocks the calling thread until the connection is established and
+raises `SimpleSocketClientException` when it fails, so there is no need to wait
+for the `connect` event to start using the client.
+
+`ask()` is a shorthand for "send and wait for the first chunk of the answer":
+
+```python
+answer = client.ask(b'PING\r\n', timeout=5)
+if answer == b'PONG\r\n':
+    print('the server is alive')
+```
+
+The same client works against [`simple-socket-server`](https://pypi.org/project/simple-socket-server/)
+and any other TCP server:
+
+```python
+from simple_socket_server import SimpleSocketServer
+
+server = SimpleSocketServer()
+
+
+@server.on('message')
+def on_message(sock, peer, data):
+    server.send(sock, b'Hi, ' + data)
+
+
+server.run(host='0.0.0.0', port=6666)
+```
+
+## Events
+
+Handlers are called one at a time from the thread that serves the connection;
+the `connect` handler is the exception, it is called by `connect()` itself.
+
+| Event        | Arguments       | When it fires                                                                 |
+|--------------|-----------------|-------------------------------------------------------------------------------|
+| `connect`    | `host, port`    | the connection is open                                                        |
+| `message`    | `data`          | a chunk of bytes has been received                                            |
+| `disconnect` | `host, port`    | the connection is closed; the messages queued by `send()` were delivered first |
+| `error`      | `error`         | a socket error occurred; the connection is closed and `disconnect` follows    |
+
+`data` is `bytes`, `error` is an `OSError`.
+
+## API
+
+| Member                                   | Description                                                           |
+|------------------------------------------|-----------------------------------------------------------------------|
+| `SimpleSocketClient(host, port)`         | a client for one address; nothing is opened until `connect()`         |
+| `connect(timeout=None)`                  | open the connection; blocks, `SimpleSocketClientException` on failure |
+| `disconnect()`                           | stop reading, deliver the queue, then close the connection            |
+| `send(message)`                          | queue `bytes` for the server                                          |
+| `ask(message, timeout=1.)`               | send `bytes` and return the first chunk of the answer                 |
+| `is_connected`                           | `True` while the connection is open and serving messages              |
+| `host`, `port`                           | the address the client connects to                                    |
+| `on(event)`, `emit(...)`                 | inherited from `event_bus.EventBus`                                   |
+
+Notes:
+
+- `connect()` raises `RuntimeError` for a live connection: one client object
+  serves one connection at a time. After `disconnect()` it can be called again,
+  and the queue of the previous connection is delivered first.
+- `send()` never blocks and never truncates: the socket is non-blocking, so the
+  bytes are buffered and the unwritten tail is retried on the next poll, so a
+  message larger than the socket buffer arrives in full.
+- `send()` and `disconnect()` are safe to call from another thread. Delivery
+  happens during the next poll, so it can take up to the poll interval (0.1 s).
+- `disconnect()` delivers the messages already queued, so a `send()` followed by
+  a `disconnect()` still reaches the server. From another thread the call waits
+  for that to finish, for up to 5 seconds: a server that stopped reading makes the
+  rest of the queue be dropped. From an event handler it only raises the flag and
+  the serving thread closes the socket itself.
+- **A handler must not raise.** The exception breaks the serving loop, the
+  connection is closed and `message` never arrives again; the exception itself is
+  printed by the `threading` module. Do the long work in your own thread and
+  handle per-message errors inside the handler.
+- `message` carries one raw `recv()` chunk of up to 1024 bytes. There is no
+  framing: the protocol you put on top has to delimit its own messages, and
+  `ask()` returns one chunk, which may hold more than the answer or less than a
+  full line.
+- `ask()` and a `message` handler see the same chunk. `ask()` raises
+  `TimeoutError` when nothing comes within the timeout and
+  `SimpleSocketClientException` when the connection is closed while waiting.
+- The serving thread is a daemon, so a forgotten `disconnect()` does not keep the
+  interpreter alive; the messages that were not written yet are lost then.
+- Do not call `sock.close()` yourself: the client owns the socket and drops it
+  with an `error` event of `select()` if it goes away behind its back.
+
+## Compatibility
+
+- Python **3.9 and newer**, including free-threaded builds: CI runs every version
+  from 3.9 to 3.15 plus the free-threaded `3.13t`.
+- One runtime dependency: [`event-bus`](https://pypi.org/project/event-bus/).
+- Type hints are shipped with the package (`py.typed`, PEP 561), so mypy and
+  pyright see real signatures instead of `Any`.
+- Any client instance is independent: several clients may serve several
+  connections in one process.
+
+## Development
+
+```shell
+$ python -m venv .venv
+$ .venv\Scripts\activate          # Windows; on POSIX: source .venv/bin/activate
+$ pip install -e ".[dev]"          # installs the package and pytest
+$ python -m pytest
+```
+
+The test suite covers:
+
+- the lifecycle: `connect`, `is_connected`, `host`, `port`, a rejected
+  connection, a second `connect()` on a live connection and a reconnect after a
+  graceful close,
+- the message flow: the `message` event for data the server sends on its own,
+  `ask()` round trips, `send()` ordering and a 256 KiB payload in both directions,
+- concurrency: several threads calling `send()` at once,
+- disconnects: the queue delivered before `disconnect()` closes the connection, an
+  idempotent `disconnect()`, a close and a reset by the server, and `ask()` that
+  waits when the connection goes away,
+- error handling: `send()` and `ask()` on a closed client, an empty message, an
+  `ask()` timeout, and a handler that raises,
+- the public API: `__all__`, the version and the package metadata.
+
+Project layout:
+
+```
+simple_socket_client/__init__.py  the whole library
+tests/                            test suite
+pyproject.toml                    metadata, build config and pytest settings
+.github/workflows/                CI: tests on Python 3.9-3.15 and 3.13t, release pipeline
+```
+
+To build and verify a release:
+
+```shell
+$ pip install build twine
+$ python -m build
+$ python -m twine check dist/*
+```
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md). GitHub Releases are generated from the matching
+entry of that file, so the history is available both in git and on the releases
+page.
+
+## License
+
+Distributed under the BSD 3-Clause license. See [LICENSE.md](LICENSE.md) for details.

simple_socket_client-2.0/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simple-socket-client"
+description = "Simple TCP socket client with select"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.md"]
+authors = [
+    { name = "Alexey Kuznetsov", email = "mirakuru@webtoucher.ru" },
+]
+keywords = ["socket", "tcp", "client", "networking", "event-driven"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Networking",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Operating System :: Unix",
+    "Operating System :: MacOS",
+    "Typing :: Typed",
+]
+dynamic = ["version"]
+dependencies = [
+    "event-bus~=1.0.2",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/webtoucher/simple-socket-client"
+Repository = "https://github.com/webtoucher/simple-socket-client"
+Issues = "https://github.com/webtoucher/simple-socket-client/issues"
+Changelog = "https://github.com/webtoucher/simple-socket-client/blob/master/CHANGELOG.md"
+
+[tool.setuptools]
+packages = ["simple_socket_client"]
+
+[tool.setuptools.dynamic]
+version = { attr = "simple_socket_client.__version__" }
+
+[tool.setuptools.package-data]
+simple_socket_client = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

{simple-socket-client-1.4 → simple_socket_client-2.0}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+