Added pypi/pip package.

Author: zeyus

.gitignore

@@ -1,5 +1,6 @@
 __pycache__/
 .pytest_cache/
+.mypy_cache/
 .vscode/
 *.pyc
 *.pyo

README.md

@@ -18,10 +18,18 @@ Well, initially this was a fun little python 3 project from 2015, but I thought
 
 ## Installation
 
+### PyPI
+
+```
+pip install mfbluebox
+```
+
+### Development
+
 ```
 git clone https://github.com/zeyus/Python3BlueBox.git
 cd PythonBlueBox
-pip install -r requirements.txt
+pip install .
 ```
 
 ### Requirements
@@ -33,13 +41,13 @@ pip install -r requirements.txt
 ### CLI
 
 ```
-python ./bluebox.py -h
+python -m bluebox -h
 ```
 
 Output:
 
 ```
-usage: bluebox.py [-h] [-l LENGTH] [-p PAUSE] [-a AMPLITUDE] [-s SAMPLE_RATE] [-m MF] [-d] [-b BACKEND] [-r PAD_PAUSE_DURATION] [-f FILE] [-P PIPE] [-S] [-i] [-v] [sequence]
+usage: __main__.py [-h] [-l LENGTH] [-p PAUSE] [-a AMPLITUDE] [-s SAMPLE_RATE] [-m MF] [-d] [-b BACKEND] [-r PAD_PAUSE_DURATION] [-f FILE] [-P PIPE] [-S] [-i] [-v] [sequence]
 
 Generate tone sequences.
 
@@ -72,11 +80,11 @@ options:
 **Examples**
 
 ```
-python ./bluebox.py -i
+python -m bluebox -i
 ```
 
 ```
-python ./bluebox.py 123456789
+python -m bluebox 123456789
 ```
 
 ### API

bluebox/__init__.py

@@ -1,7 +1,7 @@
 import typing as t
 from .freqs import BaseMF, DTMF, MF
 
-__version__ = '0.1.0'
+__version__ = '0.1.2'
 
 _MF: t.Dict[str, t.Type[BaseMF]] = {}
 

bluebox/__main__.py

@@ -0,0 +1,6 @@
+"""CLI for bluebox"""
+
+from . import cli
+
+if __name__ == '__main__':
+    cli.bluebox()

build/lib/bluebox/__init__.py

@@ -0,0 +1,25 @@
+import typing as t
+from .freqs import BaseMF, DTMF, MF
+
+__version__ = '0.1.1'
+
+_MF: t.Dict[str, t.Type[BaseMF]] = {}
+
+
+def register_mf(name: str, backend: t.Type[BaseMF]) -> None:
+    """Register a MF set."""
+    _MF[name] = backend
+
+
+def get_mf(name: str) -> t.Type[BaseMF]:
+    """Get a MF set."""
+    return _MF[name]
+
+
+def list_mf() -> t.List[str]:
+    """List the available MF sets."""
+    return list(_MF.keys())
+
+
+register_mf('dtmf', DTMF)
+register_mf('mf', MF)

build/lib/bluebox/__main__.py

@@ -0,0 +1,6 @@
+"""CLI for bluebox"""
+
+from . import cli
+
+if __name__ == '__main__':
+    cli.bluebox()

build/lib/bluebox/backends/__init__.py

@@ -0,0 +1,25 @@
+import typing as t
+from .base import BlueboxBackend as BlueboxBackend  # noqa: F401
+from .backend_pyaudio import PyAudioBackend as PyAudioBackend  # noqa: F401
+from .backend_dummy import DummyBackend as DummyBackend  # noqa: F401
+
+_BACKENDS: t.Dict[str, t.Type[BlueboxBackend]] = {}
+
+
+def register_backend(name: str, backend: t.Type[BlueboxBackend]) -> None:
+    """Register a backend."""
+    _BACKENDS[name] = backend
+
+
+def get_backend(name: str) -> t.Type[BlueboxBackend]:
+    """Get a backend."""
+    return _BACKENDS[name]
+
+
+def list_backends() -> t.List[str]:
+    """List the available backends."""
+    return list(_BACKENDS.keys())
+
+
+register_backend('pyaudio', PyAudioBackend)
+register_backend('dummy', DummyBackend)

build/lib/bluebox/backends/backend_dummy.py

@@ -0,0 +1,76 @@
+"""backend_dummy.py
+
+This file contains the dummy backend for bluebox.
+This is used for testing and instead of generating
+sound, it can print the data to the console, or return
+it as a list.
+"""
+
+import typing as t
+import logging
+from .base import BlueboxBackend
+
+
+class DummyBackend(BlueboxBackend):
+    """DummyBackend class for the dummy backend."""
+
+    _data: t.List[float]
+
+    def __init__(
+                self,
+                sample_rate: float = 44100.0,
+                channels: int = 1,
+                amplitude: float = 1.0,
+                logger: t.Optional[logging.Logger] = None,
+                mode: str = 'print') -> None:
+        """Initialize the dummy backend."""
+        super().__init__(sample_rate, channels, amplitude, logger)
+        self._mode = mode
+        self._data = []
+
+    def _to_bytes(self, data: t.Iterator[float]) -> t.List[float]:
+        """Wrap the data in a buffer."""
+        _data = []
+        while True:
+            try:
+                d = next(data)
+                _data.append(d)
+            except StopIteration:
+                break
+
+        return _data
+
+    def play(self, data: t.Iterator[float], close=True) -> None:
+        """Play the given data."""
+        d = self._to_bytes(data)
+        if self._mode == 'print':
+            print(d)
+        elif self._mode == 'list':
+            self._data += d
+        else:
+            raise ValueError(f'Invalid mode: {self._mode}')
+
+    def play_all(self, queue: t.Iterator[t.Iterator[float]]) -> None:
+        """Play the given data and then stop."""
+        for data in queue:
+            self.play(data, close=False)
+
+    def stop(self) -> None:
+        """Stop playing the data."""
+        pass
+
+    def close(self) -> None:
+        """Close the backend."""
+        pass
+
+    def __del__(self) -> None:
+        """Delete the backend."""
+        self.close()
+
+    def get_data(self) -> t.List[float]:
+        """Get the data."""
+        return self._data
+
+    def clear_data(self) -> None:
+        """Clear the data."""
+        self._data = []

build/lib/bluebox/backends/backend_pyaudio.py

@@ -0,0 +1,141 @@
+"""backend_pyaudio.py
+
+This file contains the PyAudio backend for bluebox.
+"""
+
+import typing as t
+import logging
+import struct
+import pyaudio  # type: ignore
+from .base import BlueboxBackend
+
+
+class PyAudioBackend(BlueboxBackend):
+    """PyAudioBackend class for the PyAudio backend."""
+
+    _stream: pyaudio.Stream
+    _stream_open: bool = False
+    _device: t.Union[int, None]
+
+    def __init__(
+                self,
+                sample_rate: float = 44100.0,
+                channels: int = 1,
+                amplitude: float = 1.0,
+                logger: t.Optional[logging.Logger] = None,
+                device: t.Union[int, None] = None) -> None:
+        """Initialize the PyAudio backend."""
+        super().__init__(sample_rate, channels, amplitude, logger)
+        self._device = device
+
+    def _get_stream(
+                    self,
+                    callback: t.Optional[t.Callable] = None) -> pyaudio.Stream:
+        """Get the PyAudio stream."""
+        if not self._stream_open:
+            self._stream = pyaudio.PyAudio().open(
+                format=pyaudio.paFloat32,
+                channels=self._ch,
+                rate=int(self._sr),
+                output=True,
+                output_device_index=self._device,
+                stream_callback=callback)
+            self._stream_open = True
+        return self._stream
+
+    def _to_bytes(self, data: t.Iterator[float]) -> bytes:
+        """Wrap the data in a buffer."""
+        _data = []
+        while True:
+            try:
+                d = next(data)
+                _data.append(d)
+            except StopIteration:
+                break
+
+        return struct.pack(f'{len(_data)}f', *_data)
+
+    def play(self, data: t.Iterator[float], close=True) -> None:
+        """Play the given data."""
+        d = self._to_bytes(data)
+        self._get_stream().write(d)
+        if close:
+            self.close()
+
+    def play_all(self, queue: t.Iterator[t.Iterator[float]]) -> None:
+        """Play all the items until the end."""
+        while True:
+            try:
+                data = next(queue)
+                self.play(data, False)
+            except StopIteration:
+                break
+        self.close()
+
+    def stop(self) -> None:
+        """Stop playing the data."""
+        if self._stream_open:
+            self._stream.stop_stream()
+
+    def close(self) -> None:
+        """Close the backend."""
+        if self._stream_open:
+            self._stream.close()
+            self._stream_open = False
+
+    def __del__(self) -> None:
+        """Close the backend."""
+        self.close()
+
+
+# class PyAudioBackendNonBlocking(PyAudioBackend):
+#     """PyAudioBackendNonBlocking class for the PyAudio backend."""
+
+#     def _get_stream(
+#                     self,
+#                     callback:
+#                       t.Optional[t.Callable] = None) -> pyaudio.Stream:
+#         """Get the PyAudio stream."""
+#         if not self._stream_open:
+#             self._stream = pyaudio.PyAudio().open(
+#                 format=pyaudio.paFloat32,
+#                 channels=self._ch,
+#                 rate=int(self._sr),
+#                 output=True,
+#                 stream_callback=callback,
+#                 output_device_index=self._device)
+#             self._stream_open = True
+#         return self._stream
+
+#     @property
+#     def is_playing(self) -> bool:
+#         """Return whether the stream is playing."""
+#         if not self._stream_open:
+#             return False
+#         return self._stream.is_active()
+
+#     def play(self, data: t.Iterator[float], close=True) -> None:
+#         """Play the given data."""
+#         total_frames = len(data)
+#         frame_index = 0
+
+#         def stream_callback(
+#                             in_data: t.Optional[t.MutableSequence[bytes]],
+#                             frame_count: int,
+#                             time_info: t.Optional[dict],
+#                             status: t.Optional[int]) -> t.Tuple[
+#                                 t.Optional[t.MutableSequence[float]],
+#                                 int]:
+#             nonlocal frame_index
+#             if frame_index >= total_frames:
+#                 return (None, pyaudio.paComplete)
+#             frame_index += min(frame_count, total_frames - frame_index)
+#             return (
+#                 data[frame_index - frame_count:frame_index],
+#                 pyaudio.paContinue)
+
+#         self._get_stream(stream_callback)
+
+#     def play_all(self, queue: t.Iterator[t.MutableSequence[float]]) -> None:
+#         """Not implemented. Probably should use asyncio."""
+#         raise NotImplementedError()