brownie1 0.1.0__tar.gz

brownie1-0.1.0/.pypirc

@@ -0,0 +1,3 @@
+[pypi]
+  username = __token__
+  password = pypi-AgEIcHlwaS5vcmcCJGY0ZTVlZTgxLWYwNWQtNGYyNi1hMjZmLWQwMDlkMmVmNzA1NAACKlszLCIyYmJhY2M0NC0zZmExLTQ0YjMtOTU1NC02NGE4YWYwMDgyN2UiXQAABiDRbuhaYK5SEK3XfvfIhrzB6AUDVRj21mRRtxBa5ajkWw

brownie1-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.5
+Name: brownie1
+Version: 0.1.0
+Summary: A minimalistic chat clone
+Requires-Python: >=3.10
+Requires-Dist: bleak>=0.21.1
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# BlueChat Lite
+
+BlueChat Lite is a minimalistic clone of BlueChat. It focuses purely on Bluetooth LE (BLE) client capabilities using `bleak`, acting as a central device that connects to Nordic UART Service (NUS) compatible peripherals.
+
+It strips out the complex cryptographic authentication, file transfer chunks, and specific native GATT server implementations (like BlueZ, WinRT, and CoreBluetooth).
+
+## Features
+
+- Scan for BLE devices (`bluechat-lite devices`)
+- Connect and chat with a BLE device hosting Nordic UART Service (`bluechat-lite join <MAC_ADDRESS>`)
+- Multiplatform client support (macOS, Linux, Windows) via `bleak`.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

brownie1-0.1.0/README.md

@@ -0,0 +1,24 @@
+# BlueChat Lite
+
+BlueChat Lite is a minimalistic clone of BlueChat. It focuses purely on Bluetooth LE (BLE) client capabilities using `bleak`, acting as a central device that connects to Nordic UART Service (NUS) compatible peripherals.
+
+It strips out the complex cryptographic authentication, file transfer chunks, and specific native GATT server implementations (like BlueZ, WinRT, and CoreBluetooth).
+
+## Features
+
+- Scan for BLE devices (`bluechat-lite devices`)
+- Connect and chat with a BLE device hosting Nordic UART Service (`bluechat-lite join <MAC_ADDRESS>`)
+- Multiplatform client support (macOS, Linux, Windows) via `bleak`.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

brownie1-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "brownie1"
+version = "0.1.0"
+description = "A minimalistic chat clone"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "bleak>=0.21.1",
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21.1",
+]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "/venv",
+    "/.venv",
+    "/dist",
+    "/build",
+]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src/brownie"]
+sources = ["src"]

brownie1-0.1.0/src/brownie/__init__.py

@@ -0,0 +1 @@
+"""Brownie Lite Package"""

brownie1-0.1.0/src/brownie/cli.py

@@ -0,0 +1,72 @@
+import asyncio
+import sys
+import typer
+from rich.console import Console
+from rich.table import Table
+from brownie.core import scan_devices, BlueChatLiteClient
+
+app = typer.Typer(help="Brownie Lite - Minimalistic BLE chat client")
+console = Console()
+
+@app.command("devices")
+def list_devices(timeout: float = 5.0):
+    """Scan and list nearby BLE devices."""
+    console.print(f"Scanning for devices for {timeout} seconds...")
+    
+    async def _scan():
+        devices = await scan_devices(timeout)
+        table = Table(title="Nearby BLE Devices")
+        table.add_column("Address", style="cyan")
+        table.add_column("Name", style="green")
+        
+        for dev in devices:
+            table.add_row(dev.address, dev.name or "Unknown")
+        
+        console.print(table)
+    
+    asyncio.run(_scan())
+
+@app.command("join")
+def join(address: str):
+    """Connect to a BLE device by its MAC address."""
+    console.print(f"Connecting to {address}...")
+    
+    async def _chat():
+        client = BlueChatLiteClient(address)
+        
+        def handle_message(text: str):
+            # Print the received message to standard output using rich
+            console.print(f"\n[bold green]Peer:[/bold green] {text}")
+            # Reprint prompt since it got messed up
+            console.print("> ", end="")
+            
+        client.on_message(handle_message)
+        
+        try:
+            await client.connect()
+            console.print("[bold green]Connected! Type your messages (Ctrl+C to exit).[/bold green]")
+        except Exception as e:
+            console.print(f"[bold red]Failed to connect: {e}[/bold red]")
+            return
+
+        # Start a simple input loop
+        loop = asyncio.get_event_loop()
+        try:
+            while True:
+                # Use executor to not block asyncio event loop
+                msg = await loop.run_in_executor(None, input, "> ")
+                if msg.strip():
+                    await client.send_message(msg)
+        except (KeyboardInterrupt, EOFError):
+            console.print("\nDisconnecting...")
+        finally:
+            await client.disconnect()
+            console.print("[bold green]Disconnected.[/bold green]")
+            
+    try:
+        asyncio.run(_chat())
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+if __name__ == "__main__":
+    app()

brownie1-0.1.0/src/brownie/core.py

@@ -0,0 +1,55 @@
+import asyncio
+from typing import Callable, List, Optional
+from bleak import BleakScanner, BleakClient
+from bleak.backends.device import BLEDevice
+
+# Nordic UART Service UUIDs
+NUS_SERVICE_UUID = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
+NUS_RX_UUID = "6e400002-b5a3-f393-e0a9-e50e24dcca9e"
+NUS_TX_UUID = "6e400003-b5a3-f393-e0a9-e50e24dcca9e"
+
+async def scan_devices(timeout: float = 5.0) -> List[BLEDevice]:
+    """Scan for BLE devices."""
+    devices = await BleakScanner.discover(timeout=timeout)
+    return devices
+
+class BlueChatLiteClient:
+    def __init__(self, address: str):
+        self.address = address
+        self.client: Optional[BleakClient] = None
+        self._message_callback: Optional[Callable[[str], None]] = None
+
+    def on_message(self, callback: Callable[[str], None]):
+        """Register a callback for incoming messages."""
+        self._message_callback = callback
+
+    async def connect(self):
+        """Connect to the BLE device."""
+        self.client = BleakClient(self.address)
+        await self.client.connect()
+        # Start notifying on the TX characteristic (device to host)
+        await self.client.start_notify(NUS_TX_UUID, self._notification_handler)
+
+    async def disconnect(self):
+        """Disconnect from the BLE device."""
+        if self.client and self.client.is_connected:
+            await self.client.stop_notify(NUS_TX_UUID)
+            await self.client.disconnect()
+
+    def _notification_handler(self, sender: int, data: bytearray):
+        """Handle incoming notifications (messages)."""
+        if self._message_callback:
+            try:
+                text = data.decode("utf-8")
+                self._message_callback(text)
+            except Exception as e:
+                print(f"[Error decoding message]: {e}")
+
+    async def send_message(self, message: str):
+        """Send a message to the BLE device."""
+        if not self.client or not self.client.is_connected:
+            raise RuntimeError("Not connected")
+        
+        data = message.encode("utf-8")
+        # Send data to the RX characteristic (host to device)
+        await self.client.write_gatt_char(NUS_RX_UUID, data, response=True)

brownie1-0.1.0/tests/test_core.py

@@ -0,0 +1,79 @@
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, patch, MagicMock
+from bluechat_lite.core import scan_devices, BlueChatLiteClient, NUS_RX_UUID, NUS_TX_UUID
+
+@pytest.mark.asyncio
+async def test_scan_devices():
+    """Test device scanning mock."""
+    mock_device = MagicMock()
+    mock_device.address = "00:11:22:33:44:55"
+    mock_device.name = "Test BLE Device"
+
+    with patch('bluechat_lite.core.BleakScanner.discover', new_callable=AsyncMock) as mock_discover:
+        mock_discover.return_value = [mock_device]
+        
+        devices = await scan_devices(timeout=1.0)
+        
+        mock_discover.assert_called_once_with(timeout=1.0)
+        assert len(devices) == 1
+        assert devices[0].address == "00:11:22:33:44:55"
+
+@pytest.mark.asyncio
+async def test_client_connect_and_disconnect():
+    """Test connecting and disconnecting."""
+    with patch('bluechat_lite.core.BleakClient') as MockClient:
+        mock_client_instance = MockClient.return_value
+        mock_client_instance.connect = AsyncMock()
+        mock_client_instance.start_notify = AsyncMock()
+        mock_client_instance.stop_notify = AsyncMock()
+        mock_client_instance.disconnect = AsyncMock()
+        mock_client_instance.is_connected = True
+        
+        client = BlueChatLiteClient("00:11:22:33:44:55")
+        
+        await client.connect()
+        mock_client_instance.connect.assert_called_once()
+        mock_client_instance.start_notify.assert_called_once_with(NUS_TX_UUID, client._notification_handler)
+        
+        await client.disconnect()
+        mock_client_instance.stop_notify.assert_called_once_with(NUS_TX_UUID)
+        mock_client_instance.disconnect.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_client_send_and_receive_messages():
+    """Test sending a message and receiving a notification."""
+    with patch('bluechat_lite.core.BleakClient') as MockClient:
+        mock_client_instance = MockClient.return_value
+        mock_client_instance.connect = AsyncMock()
+        mock_client_instance.start_notify = AsyncMock()
+        mock_client_instance.write_gatt_char = AsyncMock()
+        mock_client_instance.is_connected = True
+        
+        client = BlueChatLiteClient("00:11:22:33:44:55")
+        
+        received_messages = []
+        def handler(msg):
+            received_messages.append(msg)
+            
+        client.on_message(handler)
+        
+        await client.connect()
+        
+        # Test receiving a message
+        client._notification_handler(123, b"Hello World")
+        assert len(received_messages) == 1
+        assert received_messages[0] == "Hello World"
+        
+        # Test sending a message
+        await client.send_message("Hello back")
+        mock_client_instance.write_gatt_char.assert_called_once_with(NUS_RX_UUID, b"Hello back", response=True)
+
+@pytest.mark.asyncio
+async def test_client_send_disconnected_raises_error():
+    """Test sending when disconnected raises error."""
+    client = BlueChatLiteClient("00:11:22:33:44:55")
+    # Client is not connected
+    
+    with pytest.raises(RuntimeError, match="Not connected"):
+        await client.send_message("Failed message")

brownie1-0.1.0/upload_to_pypi.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+set -e
+
+# Ensure we are in the project root
+cd "$(dirname "$0")"
+
+echo "Activating virtual environment if it exists..."
+if [ -d "venv" ]; then
+    source venv/bin/activate
+fi
+
+echo "Installing build and twine..."
+pip install --upgrade build twine
+
+echo "Cleaning up previous builds..."
+rm -rf dist/
+
+echo "Building the package..."
+python3 -m build
+
+echo "Uploading to PyPI..."
+echo "You will be prompted for your PyPI API token (username: __token__)"
+python3 -m twine upload dist/*
+
+echo "Done!"