hivemind-http-protocol 0.0.2a2__tar.gz → 0.0.3a1__tar.gz

hivemind_http_protocol-0.0.3a1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: hivemind-http-protocol
+Version: 0.0.3a1
+Summary: http network protocol for hivemind-core
+Author-email: jarbasAi <jarbasai@mailfence.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/JarbasHiveMind/hivemind-http-protocol
+Requires-Python: >=3.10
+License-File: LICENSE.md
+Requires-Dist: tornado
+Requires-Dist: hivemind-plugin-manager
+Requires-Dist: poorman_handshake>=0.1.0
+Requires-Dist: pyOpenSSL
+Requires-Dist: pybase64
+Requires-Dist: hivemind-bus-client
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: hivemind-core; extra == "test"
+Requires-Dist: hivemind-bus-client; extra == "test"
+Requires-Dist: ovos-bus-client; extra == "test"
+Requires-Dist: ovos-utils; extra == "test"
+Requires-Dist: hivescope; extra == "test"
+Dynamic: license-file

hivemind_http_protocol-0.0.3a1/README.md

@@ -0,0 +1,121 @@
+# hivemind-http-protocol
+
+REST/HTTP transport plugin for [hivemind-core](https://github.com/JarbasHiveMind/HiveMind-core).
+
+An alternative to the default WebSocket transport. Clients use HTTP polling (POST to send,
+GET to receive) instead of a persistent WebSocket connection. Suitable for environments where
+long-lived TCP connections are not possible (firewalls, IoT gateways, HTTP-only proxies).
+
+## Where it fits
+
+```
+hivemind-core
+  └── hivemind-plugin-manager  (NetworkProtocolFactory loads plugins by entry-point)
+        └── hivemind-http-protocol  ← this repo
+              └── Tornado HTTP server (REST endpoints)
+```
+
+The plugin registers under the `hivemind.network.protocol` entry-point group as
+`hivemind-http-plugin`. It can run alongside the WebSocket transport if both are listed
+in the `network_protocol` config.
+
+## Install
+
+```bash
+pip install hivemind-http-protocol
+```
+
+## Quickstart
+
+Add to `~/.config/hivemind-core/server.json`:
+
+```json
+{
+  "network_protocol": {
+    "module": "hivemind-http-plugin",
+    "hivemind-http-plugin": {
+      "host": "0.0.0.0",
+      "port": 5679
+    }
+  }
+}
+```
+
+Start hivemind-core:
+
+```bash
+hivemind-core listen
+```
+
+### Running alongside WebSocket
+
+Both transports can run at the same time by configuring them both:
+
+```json
+{
+  "network_protocol": {
+    "hivemind-websocket-plugin": {
+      "host": "0.0.0.0",
+      "port": 5678
+    },
+    "hivemind-http-plugin": {
+      "host": "0.0.0.0",
+      "port": 5679
+    }
+  }
+}
+```
+
+### Python client example
+
+```python
+from hivemind_bus_client.http_client import HiveMindHTTPClient, BinaryDataCallbacks
+from hivemind_bus_client.message import HiveMessage, HiveMessageType
+from ovos_bus_client.message import Message
+
+
+class MyBinaryCallbacks(BinaryDataCallbacks):
+    def handle_receive_tts(self, bin_data: bytes, utterance: str,
+                           lang: str, file_name: str):
+        print(f"received {len(bin_data)} bytes of TTS for: {utterance}")
+
+
+client = HiveMindHTTPClient(
+    host="http://localhost",
+    port=5679,
+    bin_callbacks=MyBinaryCallbacks(),
+)
+client.emit(HiveMessage(HiveMessageType.BUS,
+                        Message("speak:synth", {"utterance": "hello world"})))
+```
+
+## Configuration reference
+
+| Key | Default | Description |
+|---|---|---|
+| `host` | `0.0.0.0` | Bind address. |
+| `port` | `5679` | Listen port. |
+| `ssl` | `false` | Enable TLS. |
+| `cert_dir` | `$XDG_DATA_HOME/hivemind` | Directory for TLS cert/key files. |
+| `cert_name` | `hivemind` | Base filename for cert and key. |
+
+## REST API
+
+Authentication uses an HTTP `authorization` parameter (not a header) containing
+a Base64-encoded `useragent:access_key` string.
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/connect` | POST | Register a client session. Parameters: `authorization`. |
+| `/disconnect` | POST | Remove a client session. Parameters: `authorization`. |
+| `/send_message` | POST | Send a HiveMessage. Parameters: `authorization`, `message`. |
+| `/get_messages` | GET | Poll for pending text messages. Parameters: `authorization`. |
+| `/get_binary_messages` | GET | Poll for pending binary messages (Base64-encoded). Parameters: `authorization`. |
+
+See [docs/api.md](docs/api.md) for full endpoint documentation.
+
+## Docs
+
+- [docs/api.md](docs/api.md) — REST endpoint reference
+- [docs/architecture.md](docs/architecture.md) — handler lifecycle, polling model, TLS
+- [docs/operations.md](docs/operations.md) — authoring a transport plugin

{hivemind_http_protocol-0.0.2a2 → hivemind_http_protocol-0.0.3a1}/hivemind_http_protocol/__init__.py

@@ -117,8 +117,7 @@ class HiveMindHttpProtocol(NetworkProtocol):
             cert.gmtime_adj_notAfter(10 * 365 * 24 * 60 * 60)
             cert.set_issuer(cert.get_subject())
             cert.set_pubkey(k)
-            # TODO: Don't use SHA1
-            cert.sign(k, "sha1")
+            cert.sign(k, "sha256")
 
             open(cert_path, "wb").write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
             open(key_path, "wb").write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k))
@@ -178,7 +177,6 @@ class HiveMindHttpHandler(web.RequestHandler):
 
         client.name = f"{useragent}::{user.client_id}::{user.name}"
         client.crypto_key = user.crypto_key
-        client.msg_blacklist = user.message_blacklist or []
         client.skill_blacklist = user.skill_blacklist or []
         client.intent_blacklist = user.intent_blacklist or []
         client.allowed_types = user.allowed_types

hivemind_http_protocol-0.0.3a1/hivemind_http_protocol/version.py

@@ -0,0 +1,8 @@
+# START_VERSION_BLOCK
+VERSION_MAJOR = 0
+VERSION_MINOR = 0
+VERSION_BUILD = 3
+VERSION_ALPHA = 1
+# END_VERSION_BLOCK
+
+__version__ = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}" + (f"a{VERSION_ALPHA}" if VERSION_ALPHA else "")

hivemind_http_protocol-0.0.3a1/hivemind_http_protocol.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: hivemind-http-protocol
+Version: 0.0.3a1
+Summary: http network protocol for hivemind-core
+Author-email: jarbasAi <jarbasai@mailfence.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/JarbasHiveMind/hivemind-http-protocol
+Requires-Python: >=3.10
+License-File: LICENSE.md
+Requires-Dist: tornado
+Requires-Dist: hivemind-plugin-manager
+Requires-Dist: poorman_handshake>=0.1.0
+Requires-Dist: pyOpenSSL
+Requires-Dist: pybase64
+Requires-Dist: hivemind-bus-client
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: hivemind-core; extra == "test"
+Requires-Dist: hivemind-bus-client; extra == "test"
+Requires-Dist: ovos-bus-client; extra == "test"
+Requires-Dist: ovos-utils; extra == "test"
+Requires-Dist: hivescope; extra == "test"
+Dynamic: license-file

{hivemind_http_protocol-0.0.2a2 → hivemind_http_protocol-0.0.3a1}/hivemind_http_protocol.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE.md
 README.md
-setup.py
+pyproject.toml
 hivemind_http_protocol/__init__.py
 hivemind_http_protocol/version.py
 hivemind_http_protocol.egg-info/PKG-INFO
@@ -8,4 +8,7 @@ hivemind_http_protocol.egg-info/SOURCES.txt
 hivemind_http_protocol.egg-info/dependency_links.txt
 hivemind_http_protocol.egg-info/entry_points.txt
 hivemind_http_protocol.egg-info/requires.txt
-hivemind_http_protocol.egg-info/top_level.txt
+hivemind_http_protocol.egg-info/top_level.txt
+tests/test_decode_auth.py
+tests/test_handlers.py
+tests/test_protocol_unit.py

hivemind_http_protocol-0.0.3a1/hivemind_http_protocol.egg-info/requires.txt

@@ -0,0 +1,15 @@
+tornado
+hivemind-plugin-manager
+poorman_handshake>=0.1.0
+pyOpenSSL
+pybase64
+hivemind-bus-client
+
+[test]
+pytest
+pytest-cov
+hivemind-core
+hivemind-bus-client
+ovos-bus-client
+ovos-utils
+hivescope

hivemind_http_protocol-0.0.3a1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hivemind-http-protocol"
+dynamic = ["version"]
+description = "http network protocol for hivemind-core"
+license = "Apache-2.0"
+authors = [
+    { name = "jarbasAi", email = "jarbasai@mailfence.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "tornado",
+    "hivemind-plugin-manager",
+    "poorman_handshake>=0.1.0",
+    "pyOpenSSL",
+    "pybase64",
+    "hivemind-bus-client",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+    "hivemind-core",
+    "hivemind-bus-client",
+    "ovos-bus-client",
+    "ovos-utils",
+    "hivescope",
+]
+
+[project.urls]
+Homepage = "https://github.com/JarbasHiveMind/hivemind-http-protocol"
+
+[project.entry-points."hivemind.network.protocol"]
+"hivemind-http-plugin" = "hivemind_http_protocol:HiveMindHttpProtocol"
+
+[tool.setuptools.dynamic]
+version = { attr = "hivemind_http_protocol.version.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hivemind_http_protocol*"]

hivemind_http_protocol-0.0.3a1/tests/test_decode_auth.py

@@ -0,0 +1,61 @@
+"""Unit tests for HiveMindHttpHandler.decode_auth.
+
+decode_auth parses a base64-encoded "useragent:key" string passed as the
+`authorization` query parameter.  Valid input splits on the first colon;
+everything to the left is the useragent, everything to the right is the
+API key.  When the parameter is absent or malformed the method returns
+(None, None) with a 400 status set.
+"""
+import pybase64
+import pytest
+from unittest.mock import patch, MagicMock
+
+from hivemind_http_protocol import HiveMindHttpHandler
+
+
+def _encode(s: str) -> str:
+    return pybase64.b64encode(s.encode("utf-8")).decode("ascii")
+
+
+def _make_handler(auth_value: str):
+    """Return a HiveMindHttpHandler instance whose get_argument() returns auth_value."""
+    handler = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+    handler.get_argument = MagicMock(return_value=auth_value)
+    handler.set_status = MagicMock()
+    return handler
+
+
+class TestDecodeAuthValid:
+    def test_simple_useragent_and_key(self):
+        h = _make_handler(_encode("myagent:secretkey"))
+        useragent, key = h.decode_auth()
+        assert useragent == "myagent"
+        assert key == "secretkey"
+
+    def test_key_with_colon_splits_on_first(self):
+        # The current implementation splits on all colons and returns
+        # a list — the caller is expected to consume index 0 and 1.
+        h = _make_handler(_encode("agent:secretkey"))
+        result = h.decode_auth()
+        assert result[0] == "agent"
+        assert result[1] == "secretkey"
+
+    def test_unicode_values(self):
+        h = _make_handler(_encode("ünïcødé:kéy"))
+        useragent, key = h.decode_auth()
+        assert useragent == "ünïcødé"
+        assert key == "kéy"
+
+
+class TestDecodeAuthMissing:
+    def test_empty_auth_returns_none_pair(self):
+        h = _make_handler("")
+        result = h.decode_auth()
+        assert result == (None, None)
+        h.set_status.assert_called_once_with(400)
+
+    def test_none_value_treated_as_missing(self):
+        h = _make_handler(None)
+        result = h.decode_auth()
+        assert result == (None, None)
+        h.set_status.assert_called_once_with(400)

hivemind_http_protocol-0.0.3a1/tests/test_handlers.py

@@ -0,0 +1,547 @@
+"""Unit tests for HiveMindHttpHandler and all derived handler classes.
+
+Covers lines 147-347 (get_client, ConnectHandler, DisconnectHandler,
+SendMessageHandler, GetMessagesHandler, GetBinMessagesHandler).
+
+Uses a real MasterNode from hivescope (so HiveMindClientConnection gets a
+valid identity/private-key path) but patches the DB and protocol callbacks
+to keep tests deterministic and side-effect-free.
+"""
+import asyncio
+from collections import defaultdict
+from queue import Queue
+from unittest.mock import MagicMock, patch, call
+
+import pybase64
+import pytest
+
+from hivemind_http_protocol import (
+    HiveMindHttpHandler,
+    ConnectHandler,
+    DisconnectHandler,
+    SendMessageHandler,
+    GetMessagesHandler,
+    GetBinMessagesHandler,
+)
+
+
+# ---------------------------------------------------------------------------
+# Module-level fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def master():
+    """One MasterNode reused across all tests in this module."""
+    hivescope = pytest.importorskip("hivescope")
+    from hivescope.node import MasterNode
+    return MasterNode.create("HH", require_crypto=False, handshake_enabled=True)
+
+
+def _encode(s: str) -> str:
+    return pybase64.b64encode(s.encode("utf-8")).decode("ascii")
+
+
+def _make_user(
+    *,
+    client_id=42,
+    name="testclient",
+    crypto_key="cryptokey",
+    skill_blacklist=None,
+    intent_blacklist=None,
+    allowed_types=None,
+    can_propagate=True,
+    can_escalate=True,
+    is_admin=False,
+    password=None,
+):
+    u = MagicMock()
+    u.client_id = client_id
+    u.name = name
+    u.crypto_key = crypto_key
+    u.skill_blacklist = skill_blacklist
+    u.intent_blacklist = intent_blacklist
+    u.allowed_types = allowed_types or []
+    u.can_propagate = can_propagate
+    u.can_escalate = can_escalate
+    u.is_admin = is_admin
+    u.password = password
+    return u
+
+
+def _clean_class_state():
+    """Reset class-level dicts to prevent test bleed."""
+    HiveMindHttpHandler.clients = {}
+    HiveMindHttpHandler.undelivered = defaultdict(Queue)
+    HiveMindHttpHandler.undelivered_bin = defaultdict(Queue)
+
+
+def _make_handler(cls, auth_value, proto, *, extra_get_arg=None):
+    """Return a handler instance bypassing Tornado's __init__."""
+    _clean_class_state()
+    cls.hm_protocol = proto
+
+    h = cls.__new__(cls)
+    h.set_status = MagicMock()
+    h.write = MagicMock()
+
+    def _get_arg(name, default=""):
+        if name == "authorization":
+            return auth_value
+        if extra_get_arg and name in extra_get_arg:
+            return extra_get_arg[name]
+        return default
+
+    h.get_argument = MagicMock(side_effect=_get_arg)
+    return h
+
+
+def _run(coro):
+    return asyncio.get_event_loop().run_until_complete(coro)
+
+
+# ---------------------------------------------------------------------------
+# get_client
+# ---------------------------------------------------------------------------
+
+class TestGetClient:
+    def test_returns_cached_client(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        existing = MagicMock()
+        HiveMindHttpHandler.clients["mykey"] = existing
+
+        h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+        result = h.get_client("agent", "mykey", cache=True)
+        assert result is existing
+
+    def test_invalid_key_returns_none(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        with patch.object(proto.db, "get_client_by_api_key", return_value=None):
+            with patch.object(proto, "handle_invalid_key_connected") as mock_invalid:
+                h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+                result = h.get_client("agent", "badkey", cache=False)
+                assert result is None
+                mock_invalid.assert_called_once()
+
+    def test_valid_key_builds_client(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            result = h.get_client("agent", "validkey", cache=False)
+            assert result is not None
+            assert result.crypto_key == user.crypto_key
+            assert result.is_admin == user.is_admin
+            assert result.can_propagate == user.can_propagate
+
+    def test_valid_key_caches_client(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            result = h.get_client("agent", "cachekey", cache=True)
+            assert HiveMindHttpHandler.clients.get("cachekey") is result
+
+    def test_no_cache_does_not_store(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            h.get_client("agent", "nocachekey", cache=False)
+            assert "nocachekey" not in HiveMindHttpHandler.clients
+
+    def test_user_with_password_sets_handshake(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user(password="hunter2")
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            result = h.get_client("agent", "pwdkey", cache=False)
+            assert result is not None
+            assert result.pswd_handshake is not None
+
+    def test_user_without_password_no_handshake(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user(password=None)
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            result = h.get_client("agent", "nopwdkey", cache=False)
+            assert result is not None
+            assert not getattr(result, "pswd_handshake", None)
+
+    def test_do_send_text_goes_to_undelivered(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            client = h.get_client("agent", "sendkey", cache=False)
+            client.send_msg("hello", is_bin=False)
+            assert not HiveMindHttpHandler.undelivered["sendkey"].empty()
+            assert HiveMindHttpHandler.undelivered["sendkey"].get() == "hello"
+
+    def test_do_send_binary_goes_to_undelivered_bin(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            client = h.get_client("agent", "binkey", cache=False)
+            client.send_msg(b"\x00\x01", is_bin=True)
+            assert not HiveMindHttpHandler.undelivered_bin["binkey"].empty()
+
+    def test_do_disconnect_removes_client_and_queue(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            client = h.get_client("agent", "disckey", cache=True)
+            HiveMindHttpHandler.undelivered["disckey"].put("msg")
+            client.disconnect()
+            assert "disckey" not in HiveMindHttpHandler.clients
+            assert "disckey" not in HiveMindHttpHandler.undelivered
+
+    def test_skill_blacklist_none_defaults_to_empty(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user(skill_blacklist=None)
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            client = h.get_client("agent", "blkey", cache=False)
+            assert client.skill_blacklist == []
+
+    def test_intent_blacklist_none_defaults_to_empty(self, master):
+        proto = master.hm_protocol
+        _clean_class_state()
+        HiveMindHttpHandler.hm_protocol = proto
+
+        user = _make_user(intent_blacklist=None)
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = HiveMindHttpHandler.__new__(HiveMindHttpHandler)
+            client = h.get_client("agent", "iblkey", cache=False)
+            assert client.intent_blacklist == []
+
+
+# ---------------------------------------------------------------------------
+# ConnectHandler
+# ---------------------------------------------------------------------------
+
+class TestConnectHandler:
+    def test_missing_auth_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(ConnectHandler, "", proto)
+        _run(h.post())
+        h.write.assert_called_with({"error": "Missing authorization"})
+
+    def test_invalid_key_does_not_call_handle_new_client(self, master):
+        proto = master.hm_protocol
+        with patch.object(proto.db, "get_client_by_api_key", return_value=None):
+            with patch.object(proto, "handle_invalid_key_connected"):
+                with patch.object(proto, "handle_new_client") as mock_new:
+                    h = _make_handler(ConnectHandler, _encode("agent:badkey"), proto)
+                    _run(h.post())
+                    mock_new.assert_not_called()
+
+    def test_valid_connect_calls_handle_new_client(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_new_client") as mock_new:
+                h = _make_handler(ConnectHandler, _encode("agent:validkey"), proto)
+                _run(h.post())
+                mock_new.assert_called_once()
+                h.write.assert_called_with({"status": "Connected"})
+
+    def test_no_crypto_key_handshake_disabled_require_crypto_triggers_invalid_protocol(self, master):
+        proto = master.hm_protocol
+        user = _make_user(crypto_key=None)
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_invalid_protocol_version") as mock_ipv:
+                with patch.object(proto, "handle_new_client") as mock_new:
+                    with patch.object(type(proto), "handshake_enabled",
+                                      new_callable=lambda: property(lambda s: False)):
+                        with patch.object(type(proto), "require_crypto",
+                                          new_callable=lambda: property(lambda s: True)):
+                            h = _make_handler(ConnectHandler, _encode("agent:key"), proto)
+                            _run(h.post())
+                            mock_ipv.assert_called_once()
+                            mock_new.assert_not_called()
+
+    def test_connect_exception_returns_500(self, master):
+        proto = master.hm_protocol
+        with patch.object(proto.db, "sync", side_effect=RuntimeError("boom")):
+            h = _make_handler(ConnectHandler, _encode("agent:key"), proto)
+            _run(h.post())
+            h.set_status.assert_called_with(500)
+            h.write.assert_called_with({"error": "Connection failed"})
+
+
+# ---------------------------------------------------------------------------
+# DisconnectHandler
+# ---------------------------------------------------------------------------
+
+class TestDisconnectHandler:
+    def test_missing_auth_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(DisconnectHandler, "", proto)
+        _run(h.post())
+        h.write.assert_called_with({"error": "Missing authorization"})
+
+    def test_not_connected_returns_already_disconnected(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(DisconnectHandler, _encode("agent:key"), proto)
+        # clients is empty after _clean_class_state
+        _run(h.post())
+        h.write.assert_called_with({"error": "Already Disconnected"})
+
+    def test_connected_client_is_disconnected(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_client_disconnected") as mock_disc:
+                h = _make_handler(DisconnectHandler, _encode("agent:disckey"), proto)
+                mock_client = MagicMock()
+                DisconnectHandler.clients["disckey"] = mock_client
+                _run(h.post())
+                mock_disc.assert_called_once()
+                h.write.assert_called_with({"status": "Disconnected"})
+
+    def test_disconnect_exception_returns_500(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_client_disconnected",
+                               side_effect=RuntimeError("fail")):
+                h = _make_handler(DisconnectHandler, _encode("agent:errkey"), proto)
+                DisconnectHandler.clients["errkey"] = MagicMock()
+                _run(h.post())
+                h.set_status.assert_called_with(500)
+                h.write.assert_called_with({"error": "Disconnection failed"})
+
+
+# ---------------------------------------------------------------------------
+# SendMessageHandler
+# ---------------------------------------------------------------------------
+
+class TestSendMessageHandler:
+    def test_missing_auth_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(SendMessageHandler, "", proto)
+        _run(h.post())
+        h.write.assert_called_with({"error": "Missing authorization"})
+
+    def test_not_connected_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(SendMessageHandler, _encode("agent:key"), proto)
+        # clients empty
+        _run(h.post())
+        h.write.assert_called_with({"error": "Client is not connected"})
+
+    def test_missing_message_returns_400(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            h = _make_handler(SendMessageHandler, _encode("agent:msgkey"), proto,
+                              extra_get_arg={"message": ""})
+            SendMessageHandler.clients["msgkey"] = MagicMock()
+            _run(h.post())
+            h.set_status.assert_called_with(400)
+            h.write.assert_called_with({"error": "Missing message"})
+
+    def test_valid_message_dispatched(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+
+        from hivemind_bus_client.message import HiveMessage, HiveMessageType
+        from ovos_bus_client.message import Message
+        bus_msg = Message("test_msg", {})
+        hive_msg = HiveMessage(HiveMessageType.BUS, payload=bus_msg)
+
+        mock_client = MagicMock()
+        mock_client.decode.return_value = hive_msg
+
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_message") as mock_handle:
+                h = _make_handler(SendMessageHandler, _encode("agent:sendmsg"), proto,
+                                  extra_get_arg={"message": "encoded_payload"})
+                # inject mock client to avoid re-building from DB
+                SendMessageHandler.clients["sendmsg"] = mock_client
+                _run(h.post())
+                mock_handle.assert_called_once()
+                h.write.assert_called_with({"status": "message sent"})
+
+    def test_b64_audio_message_dispatched(self, master):
+        proto = master.hm_protocol
+        user = _make_user()
+
+        from hivemind_bus_client.message import HiveMessage, HiveMessageType
+        from ovos_bus_client.message import Message
+        bus_msg = Message("recognizer_loop:b64_audio", {})
+        hive_msg = HiveMessage(HiveMessageType.BUS, payload=bus_msg)
+
+        mock_client = MagicMock()
+        mock_client.decode.return_value = hive_msg
+
+        with patch.object(proto.db, "get_client_by_api_key", return_value=user):
+            with patch.object(proto, "handle_message") as mock_handle:
+                h = _make_handler(SendMessageHandler, _encode("agent:audiokey"), proto,
+                                  extra_get_arg={"message": "audio_encoded"})
+                SendMessageHandler.clients["audiokey"] = mock_client
+                _run(h.post())
+                mock_handle.assert_called_once()
+                h.write.assert_called_with({"status": "message sent"})
+
+    def test_send_exception_returns_500(self, master):
+        proto = master.hm_protocol
+        with patch.object(proto.db, "sync", side_effect=RuntimeError("boom")):
+            h = _make_handler(SendMessageHandler, _encode("agent:errkey"), proto,
+                              extra_get_arg={"message": "msg"})
+            SendMessageHandler.clients["errkey"] = MagicMock()
+            _run(h.post())
+            h.set_status.assert_called_with(500)
+            h.write.assert_called_with({"error": "Message sending failed"})
+
+
+# ---------------------------------------------------------------------------
+# GetMessagesHandler
+# ---------------------------------------------------------------------------
+
+class TestGetMessagesHandler:
+    def test_missing_auth_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, "", proto)
+        _run(h.get())
+        h.write.assert_called_with({"error": "Missing authorization"})
+
+    def test_not_connected_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, _encode("agent:key"), proto)
+        _run(h.get())
+        h.write.assert_called_with({"error": "Client is not connected"})
+
+    def test_empty_queue_returns_empty_messages(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, _encode("agent:emptykey"), proto)
+        GetMessagesHandler.clients["emptykey"] = MagicMock()
+        _run(h.get())
+        h.write.assert_called_with({"status": "messages retrieved", "messages": []})
+
+    def test_queued_messages_are_returned(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, _encode("agent:qkey"), proto)
+        GetMessagesHandler.clients["qkey"] = MagicMock()
+        HiveMindHttpHandler.undelivered["qkey"].put("msg1")
+        HiveMindHttpHandler.undelivered["qkey"].put("msg2")
+        _run(h.get())
+        h.write.assert_called_with({"status": "messages retrieved", "messages": ["msg1", "msg2"]})
+
+    def test_get_messages_exception_returns_500(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, _encode("agent:exckey"), proto)
+        GetMessagesHandler.clients["exckey"] = MagicMock()
+        with patch.object(HiveMindHttpHandler.undelivered["exckey"], "empty",
+                          side_effect=RuntimeError("fail")):
+            _run(h.get())
+        h.set_status.assert_called_with(500)
+        h.write.assert_called_with({"error": "Retrieving messages failed"})
+
+    def test_get_nowait_exception_breaks_loop(self, master):
+        """Inner except: get_nowait raises while queue reports non-empty."""
+        proto = master.hm_protocol
+        h = _make_handler(GetMessagesHandler, _encode("agent:getnowaitkey"), proto)
+        GetMessagesHandler.clients["getnowaitkey"] = MagicMock()
+
+        mock_queue = MagicMock()
+        mock_queue.empty.return_value = False
+        mock_queue.get_nowait.side_effect = RuntimeError("get_nowait fail")
+        HiveMindHttpHandler.undelivered["getnowaitkey"] = mock_queue
+
+        _run(h.get())
+        # The inner except breaks; we still write the (empty) messages list
+        h.write.assert_called_with({"status": "messages retrieved", "messages": []})
+
+
+# ---------------------------------------------------------------------------
+# GetBinMessagesHandler
+# ---------------------------------------------------------------------------
+
+class TestGetBinMessagesHandler:
+    def test_missing_auth_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, "", proto)
+        _run(h.get())
+        h.write.assert_called_with({"error": "Missing authorization"})
+
+    def test_not_connected_returns_error(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, _encode("agent:key"), proto)
+        _run(h.get())
+        h.write.assert_called_with({"error": "Client is not connected"})
+
+    def test_empty_queue_returns_empty_messages(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, _encode("agent:binempty"), proto)
+        GetBinMessagesHandler.clients["binempty"] = MagicMock()
+        _run(h.get())
+        h.write.assert_called_with({"status": "messages retrieved", "b64_messages": []})
+
+    def test_queued_bin_messages_are_returned(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, _encode("agent:binq"), proto)
+        GetBinMessagesHandler.clients["binq"] = MagicMock()
+        HiveMindHttpHandler.undelivered_bin["binq"].put("b64data1")
+        HiveMindHttpHandler.undelivered_bin["binq"].put("b64data2")
+        _run(h.get())
+        h.write.assert_called_with({"status": "messages retrieved", "b64_messages": ["b64data1", "b64data2"]})
+
+    def test_get_bin_messages_exception_returns_500(self, master):
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, _encode("agent:binexc"), proto)
+        GetBinMessagesHandler.clients["binexc"] = MagicMock()
+        with patch.object(HiveMindHttpHandler.undelivered_bin["binexc"], "empty",
+                          side_effect=RuntimeError("fail")):
+            _run(h.get())
+        h.set_status.assert_called_with(500)
+        h.write.assert_called_with({"error": "Retrieving messages failed"})
+
+    def test_get_nowait_exception_breaks_loop(self, master):
+        """Inner except: get_nowait raises while queue reports non-empty."""
+        proto = master.hm_protocol
+        h = _make_handler(GetBinMessagesHandler, _encode("agent:binnowait"), proto)
+        GetBinMessagesHandler.clients["binnowait"] = MagicMock()
+
+        mock_queue = MagicMock()
+        mock_queue.empty.return_value = False
+        mock_queue.get_nowait.side_effect = RuntimeError("get_nowait fail")
+        HiveMindHttpHandler.undelivered_bin["binnowait"] = mock_queue
+
+        _run(h.get())
+        h.write.assert_called_with({"status": "messages retrieved", "b64_messages": []})

hivemind_http_protocol-0.0.3a1/tests/test_protocol_unit.py

@@ -0,0 +1,138 @@
+"""Unit-level coverage for HiveMindHttpProtocol.
+
+Targets:
+- version.py module loading.
+- create_self_signed_cert() certificate / key generation.
+- run() lifecycle (plain and SSL paths).
+"""
+import os
+import socket
+import threading
+import time
+from pathlib import Path
+
+import pytest
+
+from hivemind_http_protocol import HiveMindHttpProtocol
+
+
+# --- version.py -----------------------------------------------------------
+
+def test_version_module_exposes_constants_and_string():
+    from hivemind_http_protocol import version as v
+    assert isinstance(v.VERSION_MAJOR, int)
+    assert isinstance(v.VERSION_MINOR, int)
+    assert isinstance(v.VERSION_BUILD, int)
+    assert isinstance(v.VERSION_ALPHA, int)
+    assert isinstance(v.__version__, str)
+    assert v.__version__.startswith(
+        f"{v.VERSION_MAJOR}.{v.VERSION_MINOR}.{v.VERSION_BUILD}"
+    )
+
+
+# --- self-signed cert generation ------------------------------------------
+
+def test_create_self_signed_cert_writes_files(tmp_path):
+    cert, key = HiveMindHttpProtocol.create_self_signed_cert(
+        cert_dir=str(tmp_path), name="http-test"
+    )
+    assert Path(cert).exists()
+    assert Path(key).exists()
+    assert Path(cert).read_bytes().startswith(b"-----BEGIN CERTIFICATE-----")
+    assert b"PRIVATE KEY" in Path(key).read_bytes()
+
+
+def test_create_self_signed_cert_idempotent(tmp_path):
+    c1, k1 = HiveMindHttpProtocol.create_self_signed_cert(
+        cert_dir=str(tmp_path), name="http-test"
+    )
+    mtime = os.path.getmtime(c1)
+    time.sleep(0.05)
+    c2, k2 = HiveMindHttpProtocol.create_self_signed_cert(
+        cert_dir=str(tmp_path), name="http-test"
+    )
+    assert c1 == c2 and k1 == k2
+    assert os.path.getmtime(c1) == mtime, "cert should not be rewritten"
+
+
+# --- run() lifecycle -------------------------------------------------------
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _make_mock_hm_protocol():
+    from unittest.mock import MagicMock
+    m = MagicMock()
+    m.handshake_enabled = True
+    m.require_crypto = False
+    m.clients = {}
+    return m
+
+
+def _spawn_proto(proto, *, timeout=5.0):
+    """Start proto.run() in a daemon thread; return when the port is reachable.
+
+    The thread is intentionally not stopped here — tests that only need to
+    check that the server binds can call this and let the daemon thread die
+    when the process exits.  Returns True when the port accepted a connection
+    within *timeout* seconds, False otherwise.
+    """
+    port = int(proto.config["port"])
+    host = proto.config.get("host", "127.0.0.1")
+    ready = threading.Event()
+
+    def _run():
+        import asyncio
+        from tornado.platform.asyncio import AnyThreadEventLoopPolicy
+        asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
+        proto.run()
+
+    t = threading.Thread(target=_run, daemon=True)
+    t.start()
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            s = socket.socket()
+            s.settimeout(0.3)
+            s.connect((host, port))
+            s.close()
+            return True
+        except OSError:
+            time.sleep(0.05)
+    return False
+
+
+def test_run_starts_and_serves_on_plain_http():
+    """run() actually binds a port and the HTTP server accepts connections."""
+    pytest.importorskip("hivescope")
+    from hivescope.node import MasterNode
+    master = MasterNode.create("MH", require_crypto=False, handshake_enabled=True)
+    port = _free_port()
+    proto = HiveMindHttpProtocol(
+        config={"host": "127.0.0.1", "port": port, "ssl": False},
+        hm_protocol=master.hm_protocol,
+    )
+    assert _spawn_proto(proto), "HTTP server never became reachable"
+
+
+def test_run_ssl_generates_cert(tmp_path):
+    """SSL branch: missing cert/key are generated then the server starts."""
+    pytest.importorskip("hivescope")
+    from hivescope.node import MasterNode
+    master = MasterNode.create("MH2", require_crypto=False, handshake_enabled=True)
+    port = _free_port()
+    proto = HiveMindHttpProtocol(
+        config={
+            "host": "127.0.0.1", "port": port, "ssl": True,
+            "cert_dir": str(tmp_path), "cert_name": "gen-http",
+        },
+        hm_protocol=master.hm_protocol,
+    )
+    _spawn_proto(proto, timeout=5.0)
+    # Cert files must exist regardless of whether the SSL port was reachable.
+    assert (tmp_path / "gen-http.crt").exists()
+    assert (tmp_path / "gen-http.key").exists()

hivemind_http_protocol-0.0.2a2/PKG-INFO

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: hivemind-http-protocol
-Version: 0.0.2a2
-Summary: http network protocol for hivemind-core
-Home-page: https://github.com/JarbasHiveMind/hivemind-http-protocol
-Author: jarbasAi
-Author-email: jarbasai@mailfence.com
-License: Apache-2.0
-License-File: LICENSE.md
-Requires-Dist: tornado
-Requires-Dist: hivemind-plugin-manager
-Requires-Dist: poorman_handshake>=0.1.0
-Requires-Dist: pyOpenSSL
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: summary

hivemind_http_protocol-0.0.2a2/README.md

@@ -1,158 +0,0 @@
-# HiveMind HTTP Protocol
-
-The HiveMind HTTP Protocol provides an alternative REST-based implementation for message exchange in the HiveMind ecosystem. 
-
-
----
-
-## Configuration
-
-This plugin integrates with the `hivemind-core` framework. It is not a standalone project, and its behavior is controlled by the `hivemind-core` configuration.
-
-To enable and configure the HiveMind HTTP Protocol, update the `network_protocol` entry in the `hivemind-core` configuration file. Below is an example configuration:
-
-```json
-"network_protocol": {
-    "hivemind-websocket-plugin": {
-        "host": "0.0.0.0",
-        "port": 5678
-    },
-    "hivemind-http-plugin": {
-        "host": "0.0.0.0",
-        "port": 5679
-    }
-}
-```
-
----
-## Client Library
-
-
-```python
-from hivemind_bus_client.http_client import HiveMindHTTPClient, BinaryDataCallbacks
-from hivemind_bus_client.message import HiveMessage, HiveMessageType
-from ovos_bus_client.message import Message
-
-
-class BinaryDataHandler(BinaryDataCallbacks):
-    def handle_receive_tts(self, bin_data: bytes,
-                           utterance: str,
-                           lang: str,
-                           file_name: str):
-        # we can play it or save to file or whatever
-        print(f"got {len(bin_data)} bytes of TTS audio")
-        print(f"utterance: {utterance}", f"lang: {lang}", f"file_name: {file_name}")
-        # got 33836 bytes of TTS audio
-        # utterance: hello world lang: en-US file_name: 5eb63bbbe01eeed093cb22bb8f5acdc3.wav
-        
-# not passing key etc so it uses hivemind identity file for details
-client = HiveMindHTTPClient(host="http://localhost", port=5679,
-                            bin_callbacks=BinaryDataHandler())
-
-client.emit(HiveMessage(HiveMessageType.BUS,
-                        Message("speak:synth", {"utterance": "hello world"})))
-```
-
----
-
-## REST API Documentation
-
-### Authentication
-
-Authentication is handled via an HTTP `authorization` parameter in the request. The value should be a Base64-encoded string in the format `useragent:access_key`.
-
-### Endpoints
-
-#### 1. Connect to the Server
-
-**Endpoint:** `/connect`  
-**Method:** `POST`
-
-**Request Parameters:**
-- `authorization` (string, mandatory): Base64-encoded `useragent:access_key`.
-
-**Response:**
-- `200 OK`: `{ "status": "Connected" }`
-- `400 Bad Request`: `{ "error": "Missing authorization" }`
-- `500 Internal Server Error`: `{ "error": "Connection failed" }`
-
----
-
-#### 2. Disconnect from the Server
-
-**Endpoint:** `/disconnect`  
-**Method:** `POST`
-
-**Request Parameters:**
-- `authorization` (string, mandatory): Base64-encoded `useragent:access_key`.
-
-**Response:**
-- `200 OK`: `{ "status": "Disconnected" }`
-- `400 Bad Request`: `{ "error": "Missing authorization" }`
-- `500 Internal Server Error`: `{ "error": "Disconnection failed" }`
-
----
-
-#### 3. Send a Message
-
-**Endpoint:** `/send_message`  
-**Method:** `POST`
-
-**Request Parameters:**
-- `authorization` (string, mandatory): Base64-encoded `useragent:access_key`.
-- `message` (string, mandatory): Encoded message payload.
-
-**Response:**
-- `200 OK`: `{ "status": "message sent" }`
-- `400 Bad Request`: `{ "error": "Missing message" }`
-- `500 Internal Server Error`: `{ "error": "Message sending failed" }`
-
----
-
-#### 4. Retrieve Messages
-
-**Endpoint:** `/get_messages`  
-**Method:** `GET`
-
-**Request Parameters:**
-- `authorization` (string, mandatory): Base64-encoded `useragent:access_key`.
-
-**Response:**
-- `200 OK`: `{ "messages": ["message1", "message2"] }`
-- `400 Bad Request`: `{ "error": "Missing authorization" }`
-- `500 Internal Server Error`: `{ "error": "Failed to retrieve messages" }`
-
----
-
-#### 5. Retrieve Binary Messages
-
-**Endpoint:** `/get_binary_messages`  
-**Method:** `GET`
-
-**Request Parameters:**
-- `authorization` (string, mandatory): Base64-encoded `useragent:access_key`.
-
-**Response:**
-- `200 OK`: `{ "messages": ["Base64Message1", "Base64Message2"] }`
-- `400 Bad Request`: `{ "error": "Missing authorization" }`
-- `500 Internal Server Error`: `{ "error": "Failed to retrieve messages" }`
-
----
-
-## Notes
-
-- The `connect` and `disconnect` endpoints enable state management in scenarios where persistent connections are not feasible
-- Binary messages are Base64-encoded to ensure compatibility with REST APIs, which are text-based protocols.
-
-
----
-
-## Contributing
-
-Contributions are welcome! Please submit a pull request or open an issue for bug reports or feature requests.
-
----
-
-## License
-
-This project is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.

hivemind_http_protocol-0.0.2a2/hivemind_http_protocol/version.py

@@ -1,6 +0,0 @@
-# START_VERSION_BLOCK
-VERSION_MAJOR = 0
-VERSION_MINOR = 0
-VERSION_BUILD = 2
-VERSION_ALPHA = 2
-# END_VERSION_BLOCK

hivemind_http_protocol-0.0.2a2/hivemind_http_protocol.egg-info/PKG-INFO

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: hivemind-http-protocol
-Version: 0.0.2a2
-Summary: http network protocol for hivemind-core
-Home-page: https://github.com/JarbasHiveMind/hivemind-http-protocol
-Author: jarbasAi
-Author-email: jarbasai@mailfence.com
-License: Apache-2.0
-License-File: LICENSE.md
-Requires-Dist: tornado
-Requires-Dist: hivemind-plugin-manager
-Requires-Dist: poorman_handshake>=0.1.0
-Requires-Dist: pyOpenSSL
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: summary

hivemind_http_protocol-0.0.2a2/hivemind_http_protocol.egg-info/requires.txt

@@ -1,4 +0,0 @@
-tornado
-hivemind-plugin-manager
-poorman_handshake>=0.1.0
-pyOpenSSL

hivemind_http_protocol-0.0.2a2/setup.py

@@ -1,55 +0,0 @@
-import os
-from setuptools import setup
-
-BASEDIR = os.path.abspath(os.path.dirname(__file__))
-
-
-def get_version():
-    """ Find the version of the package"""
-    version_file = os.path.join(BASEDIR, 'hivemind_http_protocol', 'version.py')
-    major, minor, build, alpha = (None, None, None, None)
-    with open(version_file) as f:
-        for line in f:
-            if 'VERSION_MAJOR' in line:
-                major = line.split('=')[1].strip()
-            elif 'VERSION_MINOR' in line:
-                minor = line.split('=')[1].strip()
-            elif 'VERSION_BUILD' in line:
-                build = line.split('=')[1].strip()
-            elif 'VERSION_ALPHA' in line:
-                alpha = line.split('=')[1].strip()
-
-            if ((major and minor and build and alpha) or
-                    '# END_VERSION_BLOCK' in line):
-                break
-    version = f"{major}.{minor}.{build}"
-    if int(alpha) > 0:
-        version += f"a{alpha}"
-    return version
-
-
-def required(requirements_file):
-    """ Read requirements file and remove comments and empty lines. """
-    with open(os.path.join(BASEDIR, requirements_file), 'r') as f:
-        requirements = f.read().splitlines()
-        if 'MYCROFT_LOOSE_REQUIREMENTS' in os.environ:
-            print('USING LOOSE REQUIREMENTS!')
-            requirements = [r.replace('==', '>=').replace('~=', '>=') for r in requirements]
-        return [pkg for pkg in requirements
-                if pkg.strip() and not pkg.startswith("#")]
-
-
-PLUGIN_ENTRY_POINT = 'hivemind-http-plugin=hivemind_http_protocol:HiveMindHttpProtocol'
-
-setup(
-    name='hivemind-http-protocol',
-    version=get_version(),
-    packages=['hivemind_http_protocol'],
-    url='https://github.com/JarbasHiveMind/hivemind-http-protocol',
-    license='Apache-2.0',
-    author='jarbasAi',
-    install_requires=required("requirements.txt"),
-    entry_points={'hivemind.network.protocol': PLUGIN_ENTRY_POINT},
-    author_email='jarbasai@mailfence.com',
-    description='http network protocol for hivemind-core'
-)