hivemind-plugin-manager 0.0.1__py3-none-any.whl

hivemind_plugin_manager/database.py

@@ -0,0 +1,264 @@
+import abc
+import json
+from dataclasses import dataclass, field
+from typing import List, Dict, Union, Any, Optional, Iterable
+
+
+ClientDict = Dict[str, Union[str, int, float, List[str]]]
+ClientTypes = Union[None, 'Client',
+                    str,  # json
+                    ClientDict,  # dict
+                    List[Union[str, ClientDict, 'Client']]  # list of dicts/json/Client
+                ]
+
+
+def cast2client(ret: ClientTypes) -> Optional[Union['Client', List['Client']]]:
+    """
+    Convert different input types (str, dict, list) to Client instances.
+
+    Args:
+        ret: The object to be cast, can be a string, dictionary, or list.
+
+    Returns:
+        A single Client instance or a list of Clients if ret is a list.
+    """
+    if ret is None or isinstance(ret, Client):
+        return ret
+    if isinstance(ret, str) or isinstance(ret, dict):
+        return Client.deserialize(ret)
+    if isinstance(ret, list):
+        return [cast2client(r) for r in ret]
+    raise TypeError("not a client object")
+
+
+@dataclass
+class Client:
+    client_id: int
+    api_key: str
+    name: str = ""
+    description: str = ""
+    is_admin: bool = False
+    last_seen: float = -1
+    intent_blacklist: List[str] = field(default_factory=list)
+    skill_blacklist: List[str] = field(default_factory=list)
+    message_blacklist: List[str] = field(default_factory=list)
+    allowed_types: List[str] = field(default_factory=list)
+    crypto_key: Optional[str] = None
+    password: Optional[str] = None
+    can_broadcast: bool = True
+    can_escalate: bool = True
+    can_propagate: bool = True
+
+    def __post_init__(self):
+        """
+        Initializes the allowed types for the Client instance if not provided.
+        """
+        if not isinstance(self.client_id, int):
+            raise ValueError("client_id should be an integer")
+        if not isinstance(self.is_admin, bool):
+            raise ValueError("is_admin should be a boolean")
+        self.allowed_types = self.allowed_types or ["recognizer_loop:utterance",
+                                                    "recognizer_loop:record_begin",
+                                                    "recognizer_loop:record_end",
+                                                    "recognizer_loop:audio_output_start",
+                                                    "recognizer_loop:audio_output_end",
+                                                    'recognizer_loop:b64_transcribe',
+                                                    'speak:b64_audio',
+                                                    "ovos.common_play.SEI.get.response"]
+        if "recognizer_loop:utterance" not in self.allowed_types:
+            self.allowed_types.append("recognizer_loop:utterance")
+
+    def serialize(self) -> str:
+        """
+        Serializes the Client instance into a JSON string.
+
+        Returns:
+            A JSON string representing the client data.
+        """
+        return json.dumps(self.__dict__, sort_keys=True, ensure_ascii=False)
+
+    @staticmethod
+    def deserialize(client_data: Union[str, Dict]) -> 'Client':
+        """
+        Deserialize a client from JSON string or dictionary into a Client instance.
+
+        Args:
+            client_data: The data to be deserialized, either a string or dictionary.
+
+        Returns:
+            A Client instance.
+        """
+        if isinstance(client_data, str):
+            client_data = json.loads(client_data)
+        # TODO filter kwargs with inspect
+        return Client(**client_data)
+
+    def __getitem__(self, item: str) -> Any:
+        """
+        Access attributes of the client via item access.
+
+        Args:
+            item: The name of the attribute.
+
+        Returns:
+            The value of the attribute.
+
+        Raises:
+            KeyError: If the attribute does not exist.
+        """
+        if hasattr(self, item):
+            return getattr(self, item)
+        raise KeyError(f"Unknown key: {item}")
+
+    def __setitem__(self, key: str, value: Any):
+        """
+        Set attributes of the client via item access.
+
+        Args:
+            key: The name of the attribute.
+            value: The value to set.
+
+        Raises:
+            ValueError: If the attribute does not exist.
+        """
+        if hasattr(self, key):
+            setattr(self, key, value)
+        else:
+            raise ValueError(f"Unknown property: {key}")
+
+    def __eq__(self, other: Any) -> bool:
+        """
+        Compares two Client instances for equality based on their serialized data.
+
+        Args:
+            other: The other Client or Client-compatible object to compare with.
+
+        Returns:
+            True if the clients are equal, False otherwise.
+        """
+        try:
+            other = cast2client(other)
+        except:
+            pass
+        if isinstance(other, Client):
+            return self.serialize() == other.serialize()
+        return False
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the Client instance.
+
+        Returns:
+            A string representing the client.
+        """
+        return self.serialize()
+
+
+class AbstractDB(abc.ABC):
+    """
+    Abstract base class for all database implementations.
+
+    All database implementations should derive from this class and implement
+    the abstract methods.
+    """
+
+    @abc.abstractmethod
+    def add_item(self, client: Client) -> bool:
+        """
+        Add a client to the database.
+
+        Args:
+            client: The client to be added.
+
+        Returns:
+            True if the addition was successful, False otherwise.
+        """
+        pass
+
+    def delete_item(self, client: Client) -> bool:
+        """
+        Delete a client from the database.
+
+        Args:
+            client: The client to be deleted.
+
+        Returns:
+            True if the deletion was successful, False otherwise.
+        """
+        # leave the deleted entry in db, do not allow reuse of client_id !
+        client = Client(client_id=client.client_id, api_key="revoked")
+        return self.update_item(client)
+
+    def update_item(self, client: Client) -> bool:
+        """
+        Update an existing client in the database.
+
+        Args:
+            client: The client to be updated.
+
+        Returns:
+            True if the update was successful, False otherwise.
+        """
+        return self.add_item(client)
+
+    def replace_item(self, old_client: Client, new_client: Client) -> bool:
+        """
+        Replace an old client with a new client.
+
+        Args:
+            old_client: The old client to be replaced.
+            new_client: The new client to add.
+
+        Returns:
+            True if the replacement was successful, False otherwise.
+        """
+        self.delete_item(old_client)
+        return self.add_item(new_client)
+
+    @abc.abstractmethod
+    def search_by_value(self, key: str, val: Union[str, bool, int, float]) -> List[Client]:
+        """
+        Search for clients by a specific key-value pair.
+
+        Args:
+            key: The key to search by.
+            val: The value to search for.
+
+        Returns:
+            A list of clients that match the search criteria.
+        """
+        pass
+
+    @abc.abstractmethod
+    def __len__(self) -> int:
+        """
+        Get the number of items in the database.
+
+        Returns:
+            The number of items in the database.
+        """
+        return 0
+
+    @abc.abstractmethod
+    def __iter__(self) -> Iterable['Client']:
+        """
+        Iterate over all clients in the database.
+
+        Returns:
+            An iterator over the clients in the database.
+        """
+        pass
+
+    def sync(self):
+        """update db from disk if needed"""
+        pass
+
+    def commit(self) -> bool:
+        """
+        Commit changes to the database.
+
+        Returns:
+            True if the commit was successful, False otherwise.
+        """
+        return True
+

hivemind_plugin_manager/protocols.py

@@ -0,0 +1,95 @@
+import abc
+import dataclasses
+from dataclasses import dataclass
+from typing import Dict, Any, Union, Optional
+
+from ovos_bus_client import MessageBusClient
+from ovos_utils.fakebus import FakeBus
+from ovos_utils.log import LOG
+
+from hivemind_bus_client.identity import NodeIdentity
+from hivemind_core.database import ClientDatabase
+from hivemind_core.protocol import HiveMindClientConnection
+
+
+@dataclass
+class _SubProtocol:
+    """base class all protocols derive from"""
+    config: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    hm_protocol: Optional['HiveMindListenerProtocol'] = None
+
+    @property
+    def identity(self) -> NodeIdentity:
+        return self.hm_protocol.identity
+
+    @property
+    def database(self) -> ClientDatabase:
+        return self.hm_protocol.db
+
+    @property
+    def clients(self) -> Dict[str, HiveMindClientConnection]:
+        return self.hm_protocol.clients
+
+
+@dataclass
+class AgentProtocol(_SubProtocol):
+    """protocol to handle Message objects, the payload of HiveMessage objects"""
+    bus: Union[FakeBus, MessageBusClient] = dataclasses.field(default_factory=FakeBus)
+    config: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    hm_protocol: Optional['HiveMindListenerProtocol'] = None
+
+
+@dataclass
+class NetworkProtocol(_SubProtocol):
+    """protocol to transport HiveMessage objects around"""
+    config: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    hm_protocol: Optional['HiveMindListenerProtocol'] = None
+
+    @abc.abstractmethod
+    def run(self):
+        pass
+
+
+@dataclass
+class BinaryDataHandlerProtocol(_SubProtocol):
+    """protocol to handle Binary data HiveMessage objects"""
+    config: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    hm_protocol: Optional['HiveMindListenerProtocol'] = None
+    agent_protocol: Optional[AgentProtocol] = None
+
+    def handle_microphone_input(self, bin_data: bytes,
+                                sample_rate: int,
+                                sample_width: int,
+                                client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary audio input: {len(bin_data)} bytes at sample_rate: {sample_rate}")
+
+    def handle_stt_transcribe_request(self, bin_data: bytes,
+                                      sample_rate: int,
+                                      sample_width: int,
+                                      lang: str,
+                                      client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary STT input: {len(bin_data)} bytes")
+
+    def handle_stt_handle_request(self, bin_data: bytes,
+                                  sample_rate: int,
+                                  sample_width: int,
+                                  lang: str,
+                                  client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary STT input: {len(bin_data)} bytes")
+
+    def handle_numpy_image(self, bin_data: bytes,
+                           camera_id: str,
+                           client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary image: {len(bin_data)} bytes")
+
+    def handle_receive_tts(self, bin_data: bytes,
+                           utterance: str,
+                           lang: str,
+                           file_name: str,
+                           client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary TTS audio: {utterance} with {len(bin_data)} bytes")
+
+    def handle_receive_file(self, bin_data: bytes,
+                            file_name: str,
+                            client: HiveMindClientConnection):
+        LOG.warning(f"Ignoring received binary file: {file_name} with {len(bin_data)} bytes")

hivemind_plugin_manager/version.py

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

hivemind_plugin_manager-0.0.1.dist-info/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Casimiro Ferreira
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

hivemind_plugin_manager-0.0.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: hivemind-plugin-manager
+Version: 0.0.1
+Summary: plugin manager for hivemind-core
+Home-page: https://github.com/JarbasHiveMind/hivemind-plugin-manager
+Author: jarbasAi
+Author-email: jarbasai@mailfence.com
+License: Apache-2.0
+Platform: UNKNOWN
+
+UNKNOWN
+
+

hivemind_plugin_manager-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+hivemind_plugin_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hivemind_plugin_manager/database.py,sha256=3Q4AOW4pP1ZpwhhofrVph7Jd7KFYdVjOiEn1ZXdSqYM,7934
+hivemind_plugin_manager/protocols.py,sha256=SrhKciz29HFabcLxURgxPh9fWINRYRXY0tuKmYHMYJU,3749
+hivemind_plugin_manager/version.py,sha256=2AngvTQ2V0oxKc9NmDOM8rBEoiyaHuChugaM8i13Zu4,114
+hivemind_plugin_manager-0.0.1.dist-info/LICENSE.md,sha256=PMMimeaRR7uyq0XNQUDDCESBPue6yOQbLgnIyAutJIY,11347
+hivemind_plugin_manager-0.0.1.dist-info/METADATA,sha256=sQw5da54UWfAZyeyYhuzuZlI6aESWajbnBwtE6oWhRg,281
+hivemind_plugin_manager-0.0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+hivemind_plugin_manager-0.0.1.dist-info/top_level.txt,sha256=XxMPRndT8xCRAUYqENufV5dkWQj_koC7aiOoHFotktg,24
+hivemind_plugin_manager-0.0.1.dist-info/RECORD,,

hivemind_plugin_manager-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hivemind_plugin_manager-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+hivemind_plugin_manager