py-youtube-search 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

py_youtube_search/__init__.py

@@ -1,6 +1,8 @@
 import re
 import aiohttp
 import asyncio
+import requests
+
 
 # Filter constants accessible to the user
 class Filters:
@@ -78,6 +80,68 @@ class YouTubeSearch:
 
         return results
 
+
+class YouTubeSearchSync:
+    def __init__(self):
+        """
+        Initialize the YouTubeSearchSync client.
+        The client is stateless; parameters are passed to the search method.
+        """
+        self.base_url = "https://www.youtube.com/results"
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+
+    def _fetch_source(self, query: str, sp: str = None):
+        params = {"search_query": query.replace(" ", "+")}
+        if sp:
+            params["sp"] = sp
+
+        response = requests.get(self.base_url, params=params, headers=self.headers)
+        return response.text
+
+    def search(self, query: str, sp: str = None, limit: int = 15):
+        """
+        Synchronously fetches and parses search results for the given query.
+        
+        Args:
+            query (str): The search query.
+            sp (str, optional): The filter string (use Filters class). Defaults to None.
+            limit (int, optional): Max number of results. Defaults to 15.
+
+        Returns:
+            list: A list of dictionaries containing video details.
+        """
+        source = self._fetch_source(query, sp)
+
+        # Regex to capture distinct JSON fields for ID, Title, Duration, and Views.
+        pattern = (
+            r'\"videoRenderer\":\{'
+            r'.+?\"videoId\":\"(?P<id>\S{11})\"'
+            r'.+?\"title\":\{\"runs\":\[\{\"text\":\"(?P<title>.+?)\"\}\]'
+            r'.+?\"lengthText\":\{.*?\"simpleText\":\"(?P<duration>.+?)\"\}'
+            r'.+?\"viewCountText\":\{\"simpleText\":\"(?P<views>.+?)\"\}'
+        )
+
+        matches = re.finditer(pattern, source)
+        
+        results = []
+        for match in matches:
+            if len(results) >= limit:
+                break
+            
+            data = match.groupdict()
+            results.append({
+                "id": data["id"],
+                "title": data["title"],
+                "duration": data["duration"],
+                "views": data["views"],
+                "url_suffix": f"/watch?v={data['id']}"
+            })
+
+        return results
+
+
 # --- Usage Example (Async) ---
 # import asyncio
 # async def main():
@@ -94,3 +158,19 @@ class YouTubeSearch:
 #     print(f"Found {len(videos2)} videos")
 #
 # asyncio.run(main())
+
+# --- Usage Example (Sync) ---
+# def main():
+#     yt = YouTubeSearchSync()
+#     
+#     # Search 1: Long videos about LangGraph
+#     print("Searching LangGraph...")
+#     videos1 = yt.search("LangGraph", sp=Filters.long_this_week, limit=5)
+#     print(f"Found {len(videos1)} videos")
+#
+#     # Search 2: Short Python tutorials (reusing the same instance)
+#     print("Searching Python...")
+#     videos2 = yt.search("Python", sp=Filters.medium_today, limit=3)
+#     print(f"Found {len(videos2)} videos")
+#
+# main()

{py_youtube_search-0.2.3.dist-info → py_youtube_search-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-youtube-search
-Version: 0.2.3
+Version: 0.2.4
 Summary: A lightweight, regex-based YouTube search library without API keys.
 Home-page: https://github.com/VishvaRam/py-youtube-search
 Author: VishvaRam
@@ -12,6 +12,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: requests>=2.25.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -25,12 +26,12 @@ Dynamic: summary
 
 # py-youtube-search
 
-A lightweight, asynchronous Python library to search YouTube videos programmatically without an API key. 
-It scrapes search results using `aiohttp` and `re`, making it fast, robust, and perfect for high-performance applications.
+A lightweight Python library to search YouTube videos programmatically without an API key. 
+It scrapes search results using regex, making it fast, robust, and perfect for both synchronous and asynchronous applications.
 
 ## Features
 
-- **Async Support**: Fully asynchronous using `aiohttp` for non-blocking execution.
+- **Async & Sync Support**: Choose between fully asynchronous (`aiohttp`) or synchronous (`requests`) implementations.
 - **Reusable Client**: Create a single instance and run multiple searches with different configurations.
 - **No API Key Required**: Search YouTube directly without setting up Google Cloud projects.
 - **Advanced Filtering**: Built-in support for duration (Medium 3-20m, Long >20m) and upload date filters.
@@ -44,15 +45,15 @@ pip install py-youtube-search
 
 ## Quick Start
 
-### 1. Basic Async Search
-Initialize the client once and run multiple searches.
+### 1. Async Search (Recommended for Concurrent Operations)
+Perfect for FastAPI, async applications, or when running multiple searches concurrently.
 
 ```python
 import asyncio
 from py_youtube_search import YouTubeSearch
 
 async def main():
-    # 1. Initialize the client (reusable)
+    # 1. Initialize the async client (reusable)
     yt = YouTubeSearch()
     
     # 2. Run a search
@@ -68,7 +69,30 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-### 2. Advanced Search with Filters
+### 2. Sync Search (Simple Scripts & Notebooks)
+Perfect for simple scripts, Jupyter notebooks, or synchronous applications.
+
+```python
+from py_youtube_search import YouTubeSearchSync
+
+def main():
+    # 1. Initialize the sync client (reusable)
+    yt = YouTubeSearchSync()
+    
+    # 2. Run a search
+    videos = yt.search("Python async tutorials", limit=5)
+
+    for v in videos:
+        print(f"Title: {v['title']}")
+        print(f"Duration: {v['duration']}")
+        print(f"Views: {v['views']}")
+        print(f"Link: https://www.youtube.com/watch?v={v['id']}\n")
+
+if __name__ == "__main__":
+    main()
+```
+
+### 3. Advanced Search with Filters (Async)
 Search for specific content, like long-form videos (>20m) uploaded this week.
 
 ```python
@@ -96,6 +120,32 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+### 4. Advanced Search with Filters (Sync)
+
+```python
+from py_youtube_search import YouTubeSearchSync, Filters
+
+def main():
+    yt = YouTubeSearchSync()
+
+    # Search 1: Long videos about LangGraph
+    print("Searching for LangGraph...")
+    videos = yt.search("LangGraph", sp=Filters.long_this_week, limit=3)
+
+    for v in videos:
+        print(f"🎥 {v['title']} | ⏱ {v['duration']} | 👁 {v['views']}")
+
+    # Search 2: Reusing the same client for a different query
+    print("\nSearching for Python...")
+    videos_py = yt.search("Python 3.12", sp=Filters.medium_today, limit=3)
+    
+    for v in videos_py:
+        print(f"🐍 {v['title']}")
+
+if __name__ == "__main__":
+    main()
+```
+
 ## Available Filters
 
 Pass these constants into the `sp` parameter of the `search()` method.
@@ -118,7 +168,7 @@ Pass these constants into the `sp` parameter of the `search()` method.
 
 ## Data Structure
 
-The `.search()` method returns a list of dictionaries:
+Both `.search()` methods return a list of dictionaries:
 
 ```json
 [
@@ -132,8 +182,55 @@ The `.search()` method returns a list of dictionaries:
 ]
 ```
 
+## API Reference
+
+### `YouTubeSearch` (Async)
+
+```python
+async def search(query: str, sp: str = None, limit: int = 15) -> list
+```
+
+**Parameters:**
+- `query` (str): The search query
+- `sp` (str, optional): Filter string from `Filters` class
+- `limit` (int, optional): Maximum number of results (default: 15)
+
+**Returns:** List of video dictionaries
+
+### `YouTubeSearchSync` (Sync)
+
+```python
+def search(query: str, sp: str = None, limit: int = 15) -> list
+```
+
+**Parameters:**
+- `query` (str): The search query
+- `sp` (str, optional): Filter string from `Filters` class
+- `limit` (int, optional): Maximum number of results (default: 15)
+
+**Returns:** List of video dictionaries
+
+## When to Use Async vs Sync?
+
+### Use `YouTubeSearch` (Async) when:
+- Building FastAPI, aiohttp, or other async web applications
+- Running multiple searches concurrently
+- Integrating with async frameworks or event loops
+
+### Use `YouTubeSearchSync` (Sync) when:
+- Writing simple scripts or automation tools
+- Working in Jupyter notebooks or interactive environments
+- Building synchronous applications (Flask, Django views, etc.)
+
 ## Dependencies
-- `aiohttp` (for async requests)
+- `aiohttp>=3.8.0` (for async version)
+- `requests>=2.25.0` (for sync version)
 
 ## License
 MIT License. See LICENSE file for details.
+
+## Contributing
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Issues
+If you encounter any problems, please file an issue on GitHub.

py_youtube_search-0.2.4.dist-info/RECORD

@@ -0,0 +1,5 @@
+py_youtube_search/__init__.py,sha256=dUemIKQyFx1Gpc_-4iZyKDvYXMWJYXtK8a8p1CZEpGA,5999
+py_youtube_search-0.2.4.dist-info/METADATA,sha256=pqGPEGid5FP5c0Pjv42N8TzM7wX84HOfpN7l4opcg3Q,6805
+py_youtube_search-0.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+py_youtube_search-0.2.4.dist-info/top_level.txt,sha256=4EMqIznKjzwgAcB_78SKaMIzZXpIxWQ4SRLeakY3fzQ,18
+py_youtube_search-0.2.4.dist-info/RECORD,,

py_youtube_search-0.2.3.dist-info/RECORD

@@ -1,5 +0,0 @@
-py_youtube_search/__init__.py,sha256=izTjs9UNT9lxj_atAEOPGa4a2kn-_URj7SkGMfDwNj4,3292
-py_youtube_search-0.2.3.dist-info/METADATA,sha256=pSiIS7-NPmQ5X7E0jfHyV8K4pDiHi8ZgXQrQa3f3iRE,4038
-py_youtube_search-0.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-py_youtube_search-0.2.3.dist-info/top_level.txt,sha256=4EMqIznKjzwgAcB_78SKaMIzZXpIxWQ4SRLeakY3fzQ,18
-py_youtube_search-0.2.3.dist-info/RECORD,,