loudly-py-sdk 0.1.0__tar.gz

loudly_py_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: loudly-py-sdk
+Version: 0.1.0
+Summary: Python SDK for Loudly Music API
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=1.0.0

loudly_py_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "loudly-py-sdk"
+version = "0.1.0"
+description = "Python SDK for Loudly Music API"
+requires-python = ">=3.8"
+dependencies = [
+    "requests>=2.25.0",
+    "python-dotenv>=1.0.0"
+]
+readme = "README.md"
+license = { text = "MIT" }
+
+[tool.uv]
+python = ">=3.8"

loudly_py_sdk-0.1.0/setup.cfg

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

loudly_py_sdk-0.1.0/src/loudly_py_sdk/__init__.py

@@ -0,0 +1,2 @@
+from .client import LoudlyClient
+from .exceptions import LoudlyAPIError

loudly_py_sdk-0.1.0/src/loudly_py_sdk/client.py

@@ -0,0 +1,401 @@
+import os
+import requests
+from typing import Optional, Dict, Any, List
+from dotenv import load_dotenv
+from .exceptions import LoudlyAPIError
+
+# Load .env variables automatically
+load_dotenv()
+
+
+class LoudlyClient:
+    DEFAULT_BASE_URL = "https://api.loudly.com/v1"
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+        timeout: float = 10.0,
+        base_url: Optional[str] = None,
+    ):
+        if config:
+            api_key = config.get("apiKey", api_key)
+
+        self.api_key = api_key or os.getenv("LOUDLY_API_KEY")
+        self.timeout = timeout
+        self.base_url = base_url or self.DEFAULT_BASE_URL
+
+        self.session = requests.Session()
+        if self.api_key:
+            self._set_auth_header(self.api_key)
+
+    # -------------------
+    # Fluent setters
+    # -------------------
+    def with_api_key(self, api_key: str) -> "LoudlyClient":
+        self._set_auth_header(api_key)
+        return self
+
+    def with_timeout(self, timeout: float) -> "LoudlyClient":
+        self.timeout = timeout
+        return self
+
+    def with_base_url(self, base_url: str) -> "LoudlyClient":
+        self.base_url = base_url
+        return self
+
+    # -------------------
+    # Internal helpers
+    # -------------------
+    def _set_auth_header(self, api_key: str):
+        self.api_key = api_key
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+
+    def _ensure_api_key(self):
+        if not self.api_key:
+            raise ValueError(
+                "No API key set. Use api_key=..., config={'apiKey': ...}, "
+                "LOUDLY_API_KEY in a .env file, or .with_api_key()."
+            )
+
+    def _request(self, method: str, path: str, params=None, json=None, headers=None):
+        self._ensure_api_key()
+        url = f"{self.base_url}{path}"
+        try:
+            resp = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json,
+                headers=headers,
+                timeout=self.timeout
+            )
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # -------------------
+    # API Methods
+    # -------------------
+
+    # 1. Genres
+    def list_genres(self) -> List[Dict[str, Any]]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        url = "https://soundtracks.loudly.com/api/ai/genres"
+        
+        try:
+            resp = requests.get(url, headers=headers, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 2. Structures
+    def list_structures(self) -> List[Dict[str, Any]]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        url = "https://soundtracks.loudly.com/api/ai/structures"
+        
+        try:
+            resp = requests.get(url, headers=headers, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 3. Random prompt
+    def get_random_prompt(self) -> Dict[str, Any]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        url = "https://soundtracks.loudly.com/api/ai/prompt/random"
+        
+        try:
+            resp = requests.get(url, headers=headers, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 4. Song tags
+    def get_song_tags(
+        self,
+        mood: Optional[List[str]] = None,
+        genre: Optional[List[str]] = None,
+        key: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        url = "https://soundtracks.loudly.com/api/songs/tags"
+        payload = {}
+        if mood: payload["mood"] = mood
+        if genre: payload["genre"] = genre
+        if key: payload["key"] = key
+        
+        try:
+            resp = requests.get(url, headers=headers, json=payload, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 5. List songs
+    def list_songs(
+        self,
+        page: int = 1,
+        per_page: int = 20
+    ) -> Dict[str, Any]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        params = {"page": page, "per_page": per_page}
+        url = "https://soundtracks.loudly.com/api/songs"
+        
+        try:
+            resp = requests.get(url, headers=headers, params=params, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 6. Song Generation
+    def generate_ai_song(
+        self,
+        genre: str,
+        genre_blend: str = "",
+        duration: Optional[int] = None,
+        energy: Optional[str] = "",
+        bpm: Optional[int] = None,
+        key_root: Optional[str] = "",
+        key_quality: Optional[str] = "",
+        instruments: Optional[str] = "",
+        structure_id: Optional[int] = None,
+        test: Optional[bool] = False
+    ) -> Dict[str, Any]:
+        """Generate AI song using form data"""
+        
+        if not genre:
+            raise ValueError("genre is required")
+        
+        self._ensure_api_key()
+        
+        url = "https://soundtracks.loudly.com/api/ai/songs"
+        
+        # Prepare form data - only include non-empty values
+        data = {"genre": genre}
+        
+        if genre_blend:
+            data["genre_blend"] = genre_blend
+        if duration is not None:
+            data["duration"] = str(duration)
+        if energy:
+            data["energy"] = energy
+        if bpm is not None:
+            data["bpm"] = str(bpm)
+        if key_root:
+            data["key_root"] = key_root
+        if key_quality:
+            data["key_quality"] = key_quality
+        if instruments:
+            data["instruments"] = instruments
+        if structure_id is not None:
+            data["structure_id"] = str(structure_id)
+        if test is not None:
+            data["test"] = str(test).lower()
+        
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+            # Don't set Content-Type - requests will set it automatically for form data
+        }
+        
+        try:
+            resp = requests.post(url, headers=headers, data=data, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 7. Song generation from prompt
+    def generate_song_from_prompt(
+        self,
+        prompt: str,
+        duration: Optional[int] = None,
+        test: Optional[bool] = False,
+        structure_id: Optional[int] = None
+    ) -> Dict[str, Any]:
+        
+        if not prompt:
+            raise ValueError("Prompt is required")
+        
+        self._ensure_api_key()
+        
+        url = "https://soundtracks.loudly.com/api/ai/prompt/songs"
+        
+        data = {"prompt": prompt}
+        
+        if duration is not None:
+            data["duration"] = str(duration)  
+        
+        if test is not None:
+            data["test"] = str(test).lower() 
+        
+        if structure_id is not None:
+            data["structure_id"] = str(structure_id)
+        
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        
+        try:
+            resp = requests.post(url, headers=headers, data=data, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+        
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+        
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}
+
+    # 8. Limits Account
+    def get_limits(
+        self,
+        date_from: Optional[str] = None,
+        date_to: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        self._ensure_api_key()
+        headers = {
+            "API-KEY": self.api_key,
+            "Accept": "application/json"
+        }
+        # Use the soundtracks.loudly.com domain for limits as well
+        url = "https://soundtracks.loudly.com/api/account/limits"
+        
+        params: Dict[str, Any] = {}
+        if date_from:
+            params["date_from"] = date_from
+        if date_to:
+            params["date_to"] = date_to
+
+        try:
+            resp = requests.get(url, headers=headers, params=params, timeout=self.timeout)
+        except requests.RequestException as e:
+            raise LoudlyAPIError(-1, f"Network error: {e}")
+
+        if not resp.ok:
+            try:
+                err = resp.json()
+                message = err.get("error", err.get("message", resp.text))
+            except ValueError:
+                message = resp.text
+            raise LoudlyAPIError(resp.status_code, message, response=resp)
+
+        try:
+            return resp.json()
+        except ValueError:
+            return {"raw": resp.text}

loudly_py_sdk-0.1.0/src/loudly_py_sdk/exceptions.py

@@ -0,0 +1,7 @@
+class LoudlyAPIError(Exception):
+    """Custom exception for Loudly API errors."""
+
+    def __init__(self, status_code: int, message: str, response=None):
+        super().__init__(f"HTTP {status_code}: {message}")
+        self.status_code = status_code
+        self.response = response

loudly_py_sdk-0.1.0/src/loudly_py_sdk.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: loudly-py-sdk
+Version: 0.1.0
+Summary: Python SDK for Loudly Music API
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=1.0.0

loudly_py_sdk-0.1.0/src/loudly_py_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/loudly_py_sdk/__init__.py
+src/loudly_py_sdk/client.py
+src/loudly_py_sdk/exceptions.py
+src/loudly_py_sdk.egg-info/PKG-INFO
+src/loudly_py_sdk.egg-info/SOURCES.txt
+src/loudly_py_sdk.egg-info/dependency_links.txt
+src/loudly_py_sdk.egg-info/requires.txt
+src/loudly_py_sdk.egg-info/top_level.txt
+tests/test_client.py

loudly_py_sdk-0.1.0/src/loudly_py_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loudly_py_sdk-0.1.0/src/loudly_py_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+python-dotenv>=1.0.0

loudly_py_sdk-0.1.0/src/loudly_py_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+loudly_py_sdk

loudly_py_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+Loudly API SDK Test Script
+Tests all major functionality of the Loudly API client with separate functions for each API call.
+"""
+
+from loudly import LoudlyClient, LoudlyAPIError
+
+
+def test_genres(sdk: LoudlyClient) -> None:
+    """Test listing available genres."""
+    print("\n=== GENRES ===")
+    try:
+        genres = sdk.list_genres()
+        print(f"Found {len(genres)} genres:")
+        for genre in genres:
+            print(f"   {genre['id']}: {genre['name']} ({genre['description']})")
+    except LoudlyAPIError as e:
+        print(f"Genres API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Genres Error: {e}")
+
+
+def test_structures(sdk: LoudlyClient) -> None:
+    """Test listing available song structures."""
+    print("\n=== STRUCTURES ===")
+    try:
+        structures = sdk.list_structures()
+        print(f" Found {len(structures)} structures:")
+        for s in structures:
+            print(f"   {s['id']}: {s['name']} ({s['description']})")
+    except LoudlyAPIError as e:
+        print(f"Structures API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Structures Error: {e}")
+
+
+def test_random_prompt(sdk: LoudlyClient) -> None:
+    """Test getting a random prompt."""
+    print("\n=== RANDOM PROMPT ===")
+    try:
+        prompt_data = sdk.get_random_prompt()
+        print(f"Random prompt: {prompt_data['prompt']}")
+    except LoudlyAPIError as e:
+        print(f"Random Prompt API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Random Prompt Error: {e}")
+
+
+def test_song_tags(sdk: LoudlyClient) -> None:
+    """Test getting song tags with filters."""
+    print("\n=== SONG TAGS ===")
+    try:
+        tags = sdk.get_song_tags(
+            mood=["Dreamy", "Laid Back", "Dark"],
+            genre=["Funk", "Beats", "Indian"],
+            key=["E Major", "Ab/G# Major"]
+        )
+        print("Song tags retrieved:")
+        print(f"Filters used: mood=['Dreamy', 'Laid Back', 'Dark'], genre=['Funk', 'Beats', 'Indian'], key=['E Major', 'Ab/G# Major']")
+        print(f"Result: {tags}")
+    except LoudlyAPIError as e:
+        print(f"Song Tags API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Song Tags Error: {e}")
+
+
+def test_list_songs(sdk: LoudlyClient) -> None:
+    """Test listing songs with pagination."""
+    print("\n=== SONGS LIST ===")
+    try:
+        songs_data = sdk.list_songs(page=1, per_page=10)
+        print(f"Found {len(songs_data['items'])} songs on page 1:")
+        for song in songs_data["items"]:
+            print(f"   {song['id']}: {song['title']} ({song['duration']} sec)")
+    except LoudlyAPIError as e:
+        print(f"List Songs API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"List Songs Error: {e}")
+
+
+def test_generate_ai_song(sdk: LoudlyClient) -> None:
+    """Test AI song generation with parameters."""
+    print("\n=== AI SONG GENERATION ===")
+    try:
+        song = sdk.generate_ai_song(
+            genre="House",
+            duration=30,
+            energy="high",
+            bpm=115,
+            key_root="D",
+            key_quality="minor",
+            instruments="Synth,Drums",
+            test=True
+        )
+        
+        print("AI Song generated successfully:")
+        print(f"Title: {song['title']}")
+        print(f"Music File: {song['music_file_path']}")
+        print(f"Duration: {song.get('duration', 'N/A')} ms")
+        print(f"BPM: {song.get('bpm', 'N/A')}")
+        print(f"Key: {song.get('key', {}).get('name', 'N/A')}")
+        
+    except LoudlyAPIError as e:
+        print(f"AI Song Generation API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"AI Song Generation Error: {e}")
+
+
+def test_generate_song_from_prompt(sdk: LoudlyClient) -> None:
+    """Test song generation from text prompt."""
+    print("\n=== SONG FROM PROMPT ===")
+    try:
+        song_from_prompt = sdk.generate_song_from_prompt(
+            prompt="A 90-second energetic house track with tropical vibes and a melodic flute line",
+            duration=30,
+            test=True
+        )
+        
+        print("Song from prompt generated successfully:")
+        print(f"Prompt: 'A 90-second energetic house track with tropical vibes and a melodic flute line'")
+        print(f"Title: {song_from_prompt['title']}")
+        print(f"Music File: {song_from_prompt['music_file_path']}")
+        print(f"Duration: {song_from_prompt['duration']} ms")
+        print(f"BPM: {song_from_prompt['bpm']}")
+        print(f"Key: {song_from_prompt['key']['name']}")
+        
+    except LoudlyAPIError as e:
+        print(f"Song from Prompt API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Song from Prompt Error: {e}")
+
+
+def test_account_limits(sdk: LoudlyClient) -> None:
+    """Test getting account limits information."""
+    print("\n=== ACCOUNT LIMITS ===")
+    try:
+        # Test without date filters
+        print("Getting current limits...")
+        limits = sdk.get_limits()
+        print("Current limits retrieved:")
+        for limit in limits.get('limits', []):
+            print(f"{limit['request_type']}: {limit['used']}/{limit['limit']} ({limit['left']} remaining)")
+        
+        top_up = limits.get('top_up', {})
+        if top_up.get('total', 0) > 0:
+            print(f"Top-up available: {top_up['available']}/{top_up['total']}")
+        
+        # Test with date range
+        print("\n Getting limits for specific date range...")
+        limits_filtered = sdk.get_limits(date_from="2025-02-25", date_to="2025-03-27")
+        print("Filtered limits retrieved:")
+        print(f"Date range: 2025-02-25 to 2025-03-27")
+        for limit in limits_filtered.get('limits', []):
+            print(f"{limit['request_type']}: {limit['used']}/{limit['limit']} ({limit['left']} remaining)")
+        
+    except LoudlyAPIError as e:
+        print(f"Account Limits API Error [{e.status_code}]: {e.message}")
+    except Exception as e:
+        print(f"Account Limits Error: {e}")
+
+
+def main():
+    """Main function to run all tests."""
+    print("Loudly API SDK Test Suite")
+    print("=" * 60)
+    
+    # Initialize SDK
+    sdk = LoudlyClient(
+        api_key="gkatOxIWWGY26B4Czb9H8UF01JGwHa2Kiigf8nTiHnI", 
+        base_url="https://soundtracks.loudly.com"
+    )
+    
+    # Run all tests
+    test_functions = [
+        test_genres,
+        test_structures,
+        test_random_prompt,
+        test_song_tags,
+        test_list_songs,
+        test_generate_ai_song,
+        test_generate_song_from_prompt,
+        test_account_limits
+    ]
+    
+    for test_func in test_functions:
+        try:
+            test_func(sdk)
+        except KeyboardInterrupt:
+            print("\n Test interrupted by user")
+            break
+        except Exception as e:
+            print(f"Unexpected error in {test_func.__name__}: {e}")
+    
+    print("\n" + "=" * 60)
+    print("Test suite completed")
+
+
+if __name__ == "__main__":
+    main()