file structure

framework/__init__.py

@@ -1 +1,2 @@
 from .redis import Redis
+from .youtube import Youtube

framework/redis.py

@@ -1,3 +1,5 @@
+from logging import Logger
+from redis.asyncio.lock import Lock
 import redis.asyncio as redis
 import pickle
 
@@ -5,20 +7,39 @@ from config import RedisConfig
 
 
 class Redis:
-    def __init__(self, config: RedisConfig) -> None:
-        self.client = redis.Redis(
+    def __init__(self, logger: Logger, config: RedisConfig) -> None:
+        self._client = redis.Redis(
             host=config.host,
             port=config.port,
             password=config.password,
             auto_close_connection_pool=False,
         )
+        self._locks: dict[str, Lock] = {}
+        self.logger = logger
 
-    async def set(self, key: str, value: any) -> None:
-        await self.client.set(key, pickle.dumps(value))
+    async def _get_lock(self, key) -> Lock:
+        if key not in self._locks:
+            self._locks[key] = self._client.lock(key)
+        return self._locks[key]
 
-    async def get(self, key: str) -> any:
-        value = await self.client.get(key)
-        return pickle.loads(value)
+    async def acquire(self, key: str) -> None:
+        lock = await self._get_lock(f"djembe:queue:{key}")
+        await lock.acquire()
+
+    async def release(self, key: str) -> None:
+        lock = await self._get_lock(f"djembe:queue:{key}")
+        await lock.release()
+
+    async def get(self, key: str):
+        self.logger.info(f"get value {key} from redis")
+        value = await self._client.get(f"djembe:queue:{key}")
+        if value:
+            return pickle.loads(value)
+        return None
+
+    async def set(self, key: str, value) -> None:
+        self.logger.info(f"set value {key} to redis")
+        await self._client.set(f"djembe:queue:{key}", pickle.dumps(value))
 
     async def close(self) -> None:
-        await self.client.close()
+        await self._client.close()

framework/youtube.py

@@ -0,0 +1,25 @@
+from yt_dlp import YoutubeDL
+from youtubesearchpython.__future__ import VideosSearch
+from asyncio import AbstractEventLoop
+
+from config import YoutubeConfig
+
+
+class Youtube:
+    def __init__(self, loop: AbstractEventLoop, config: YoutubeConfig) -> None:
+        self.params = {}
+        self.client = YoutubeDL(self.params)
+        self.loop = loop
+        self.config = config
+
+    async def searchVideo(self, query: str):
+        videosSearch = VideosSearch(
+            query, limit=1, language=self.config.language, region=self.config.region
+        )
+        return await videosSearch.next()
+
+    async def get_data(self, url: str) -> str:
+        data = await self.loop.run_in_executor(
+            None, lambda: self.client.extract_info(url, download=False)
+        )
+        print(data)