playbeats 0.1.1__tar.gz

playbeats-0.1.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: playbeats
+Version: 0.1.1
+Summary: Generate neural-network-powered beats from your terminal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygame
+Requires-Dist: torch
+Requires-Dist: numpy
+
+### Installation
+
+```bash
+pip install playbeats
+```
+
+### Usage
+
+```bash
+playbeats --bpm=80 --energy=20
+```
+
+- `--bpm` — Set the beat tempo.
+- `--energy` — Set the beat energy.
+
+### Stop Playback
+
+Press `Ctrl+C` to stop playback.
+

playbeats-0.1.1/README.md

@@ -0,0 +1,19 @@
+### Installation
+
+```bash
+pip install playbeats
+```
+
+### Usage
+
+```bash
+playbeats --bpm=80 --energy=20
+```
+
+- `--bpm` — Set the beat tempo.
+- `--energy` — Set the beat energy.
+
+### Stop Playback
+
+Press `Ctrl+C` to stop playback.
+

playbeats-0.1.1/playbeats.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: playbeats
+Version: 0.1.1
+Summary: Generate neural-network-powered beats from your terminal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygame
+Requires-Dist: torch
+Requires-Dist: numpy
+
+### Installation
+
+```bash
+pip install playbeats
+```
+
+### Usage
+
+```bash
+playbeats --bpm=80 --energy=20
+```
+
+- `--bpm` — Set the beat tempo.
+- `--energy` — Set the beat energy.
+
+### Stop Playback
+
+Press `Ctrl+C` to stop playback.
+

playbeats-0.1.1/playbeats.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+train.py
+playbeats.egg-info/PKG-INFO
+playbeats.egg-info/SOURCES.txt
+playbeats.egg-info/dependency_links.txt
+playbeats.egg-info/entry_points.txt
+playbeats.egg-info/requires.txt
+playbeats.egg-info/top_level.txt
+src/__init__.py
+src/main.py
+src/assets/beat_generator.pth
+src/assets/sounds/HIHAT.wav
+src/assets/sounds/KICK.wav
+src/assets/sounds/SAMPLE.wav
+src/assets/sounds/SNARE.wav
+src/assets/sounds/bass.wav
+src/assets/sounds/bongo.wav
+src/assets/sounds/clap.wav
+src/assets/sounds/clap_fixed.wav
+src/assets/sounds/closed-hihat.wav
+src/assets/sounds/openhihat.wav
+src/assets/sounds/tambourine.wav
+src/assets/sounds/tom-high.wav
+src/assets/sounds/tom-low.wav
+src/assets/sounds/tom-mid.wav

playbeats-0.1.1/playbeats.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

playbeats-0.1.1/playbeats.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+playbeats = src.main:main

playbeats-0.1.1/playbeats.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pygame
+torch
+numpy

playbeats-0.1.1/playbeats.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+src
+train

playbeats-0.1.1/pyproject.toml

@@ -0,0 +1,28 @@
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "playbeats"
+version = "0.1.1"
+description = "Generate neural-network-powered beats from your terminal"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pygame",
+    "torch",
+    "numpy"
+]
+
+[project.scripts]
+playbeats = "src.main:main"
+
+[tool.setuptools]
+py-modules = ["train"]
+
+[tool.setuptools.packages.find]
+include = ["src*"]
+
+[tool.setuptools.package-data]
+src = ["assets/*.pth", "assets/sounds/*.wav"]

playbeats-0.1.1/setup.cfg

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

playbeats-0.1.1/src/main.py

@@ -0,0 +1,112 @@
+import pygame
+import time
+from train import BeatGenerator
+import torch
+import random
+import sys
+import re
+
+from pathlib import Path
+
+ASSETS = Path(__file__).resolve().parent / "assets"
+
+def shuffel(sounds:list):
+    for i in range(len(sounds) -1,0,-1):
+        j = random.randint(0,i)
+        sounds[i], sounds[j] = sounds[j], sounds[i]
+    return sounds
+
+
+def main(): 
+
+    if len(sys.argv) < 3:
+        print("Error: Missing arguments.", file=sys.stderr)
+        print(f"Usage: playbeats  {sys.argv[0]} bpm energy")
+        sys.exit(1)
+    
+    
+    match1 = re.search(r"\d+", sys.argv[1]) 
+    
+    match2 = re.search(r"\d+", sys.argv[2])
+
+    if match1:
+        bpm = float(match1.group())
+    if match2:
+        energy = float(match2.group())
+    
+    duration = float(random.randint(100,1000))
+
+    model = BeatGenerator()
+
+    state_dict = torch.load(
+        ASSETS / "beat_generator.pth",
+        map_location="cpu",
+        weights_only=True
+    )
+
+
+    model.load_state_dict(state_dict)
+    
+    model.eval()
+
+    x = torch.tensor([[bpm, duration, 44100, energy]])
+
+    with torch.no_grad():
+            output = model(x)
+            beat = (torch.sigmoid(output) >= 0.5).int()
+
+    pygame.mixer.init()
+
+
+    sounds_dir = ASSETS / "sounds"
+
+    kick = pygame.mixer.Sound(str(sounds_dir / "KICK.wav"))
+    snare = pygame.mixer.Sound(str(sounds_dir / "SNARE.wav"))
+    sample = pygame.mixer.Sound(str(sounds_dir / "SAMPLE.wav"))
+    hihat = pygame.mixer.Sound(str(sounds_dir / "HIHAT.wav"))
+    bass = pygame.mixer.Sound(str(sounds_dir / "bass.wav"))
+    tom_mid = pygame.mixer.Sound(str(sounds_dir / "tom-mid.wav"))
+    tom_high = pygame.mixer.Sound(str(sounds_dir / "tom-high.wav"))
+    tom_low = pygame.mixer.Sound(str(sounds_dir / "tom-low.wav"))
+    closed_hithat = pygame.mixer.Sound(str(sounds_dir / "closed-hihat.wav"))
+    open_hihat = pygame.mixer.Sound(str(sounds_dir / "openhihat.wav"))
+    tambourine = pygame.mixer.Sound(str(sounds_dir / "tambourine.wav"))
+    bongo = pygame.mixer.Sound(str(sounds_dir / "bongo.wav"))
+    clap = pygame.mixer.Sound(str(sounds_dir / "clap.wav"))
+
+    instruments = [
+        bass,          
+        snare,        
+        tom_mid,      
+        clap,          
+        kick,          
+        open_hihat,    
+        closed_hithat, 
+        tom_high,      
+        hihat,         
+        tambourine,    
+        tom_low,        
+        sample,    
+        bongo,        
+    ]
+
+    bpm = 120
+    beat_time = 60 / bpm
+
+    try:
+        while True:
+            for i in range(64):
+                for j in range(13):
+                    if beat[0][i][j].item() == 1:
+                        instruments = shuffel(instruments)
+                        instruments[j].play()
+                time.sleep(beat_time)
+
+    except KeyboardInterrupt:
+        print("Beat playback stopped.")
+
+    finally:
+        pygame.mixer.quit()
+
+if __name__ == "__main__":
+    main()

playbeats-0.1.1/train.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""Untitled1.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1EBzJZoQPsyh-XQYCCsFwpnd93PScSpSq
+"""
+
+# from pathlib import Path
+# import glob
+# import json
+import torch.nn as nn
+
+# path = Path("/content/drive/MyDrive/training-data")
+
+# training_data = glob.glob(str(path / "*.json"))
+
+# training_tensors = []
+
+# target_tensors = []
+
+# for file in training_data:
+#     with open(file, "r") as f:
+#       data = json.load(f)
+
+#       metadata = data["metadata"]
+
+#       meta_data = [
+#             metadata["bpm"],
+#             metadata["duration"],
+#             metadata["sample_rate"],
+#             metadata["energy"]
+#         ]
+
+#     training_tensors.append(
+#         torch.tensor(meta_data, dtype=torch.float32)
+#     )
+
+#     target_tensors.append(
+#         torch.tensor(data["sequence"], dtype=torch.float32)
+#     )
+
+# X = torch.stack(training_tensors)
+# Y = torch.stack(target_tensors)
+
+class BeatGenerator(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        self.network = nn.Sequential(
+            nn.Linear(4, 128),
+            nn.ReLU(),
+
+            nn.Linear(128, 256),
+            nn.ReLU(),
+
+            nn.Linear(256, 832)
+        )
+
+    def forward(self, x):
+        x = self.network(x)
+        x = x.reshape(-1, 64, 13)
+        return x
+
+# model = BeatGenerator()
+
+# positive = Y.sum()
+
+# negative = Y.numel() - positive
+
+# loss_fc = nn.BCEWithLogitsLoss(pos_weight=negative/positive)
+
+# optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+
+# for epoch in range(20000):
+
+#   output = model(X)
+
+#   loss = loss_fc(output, Y)
+
+#   optimizer.zero_grad()
+
+#   loss.backward()
+
+#   optimizer.step()
+
+#   if (epoch + 1) % 100 == 0:
+#     print(f"Epoch {epoch + 1}, Loss: {loss.item():.4f}")
+
+
+# torch.save(model.state_dict(), "beat_generator.pth")
+
+# model = BeatGenerator()
+
+# model.load_state_dict(
+#     torch.load("beat_generator.pth", map_location="cpu", weights_only=True)
+# )
+
+# model.eval()
+
+# x = torch.tensor([[13230.0, 13235.89, 250.0, 0.12332411]])
+
+# with torch.no_grad():
+#     output = model(x)
+#     beat = (torch.sigmoid(output) >= 0.5).int()
+
+# print("Shape:", beat.shape)
+# print(beat[0])