zenx 0.6.8__tar.gz → 0.7.0__tar.gz

{zenx-0.6.8 → zenx-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zenx
-Version: 0.6.8
+Version: 0.7.0
 Summary: mini-framework
 Requires-Python: >=3.12
 Requires-Dist: curl-cffi>=0.12.0

{zenx-0.6.8 → zenx-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zenx"
-version = "0.6.8"
+version = "0.7.0"
 description = "mini-framework"
 requires-python = ">=3.12"
 dependencies = [

{zenx-0.6.8 → zenx-0.7.0}/zenx/clients/database.py

@@ -45,22 +45,7 @@ class DBClient(ABC):
 
 
     @abstractmethod
-    async def insert(self, id: str, spider_name: str) -> None:
-        ...
-
-
-    @abstractmethod
-    async def exists(self, id: str, spider_name: str) -> bool:
-        ...
-
-
-    @abstractmethod
-    async def delete(self, id: str, spider_name: str) -> None:
-        ...
-
-
-    @abstractmethod
-    async def cleanup(self, days: int) -> None:
+    async def insert(self, id: str, spider_name: str) -> bool:
         ...
 
 
@@ -87,25 +72,14 @@ class MemoryDB(DBClient):
         pass
 
 
-    async def insert(self, id: str, spider_name: str) -> None:
+    async def insert(self, id: str, spider_name: str) -> bool:
         unique_id = f"{spider_name}_{id}"
+        if unique_id in self.dq:
+            self.logger.debug("exists", id=unique_id, db=self.name)
+            return False
         self.dq.append(unique_id)
         self.logger.debug("inserted", id=unique_id, db=self.name)
-
-
-    async def exists(self, id: str, spider_name: str) -> bool:
-        unique_id = f"{spider_name}_{id}"
-        return unique_id in self.dq
-
-
-    async def delete(self, id: str, spider_name: str) -> None:
-        unique_id = f"{spider_name}_{id}"
-        self.dq.remove(unique_id)
-        self.logger.debug("deleted", id=unique_id, db=self.name)
-
-
-    async def cleanup(self, days: int) -> None:
-        pass
+        return True
 
 
     async def close(self) -> None:
@@ -123,7 +97,7 @@ try:
         def __init__(self, logger: BoundLogger, settings: Settings) -> None:
             super().__init__(logger, settings)
             self.r: Optional[redis.Redis] = None
-            self._processed_ids_zset: str = "processed:ids:zset"
+            self._record_expiry_sec = self.settings.REDIS_RECORD_EXPIRY_SECONDS
 
     
         async def start(self) -> None:
@@ -151,28 +125,15 @@ try:
             self.logger.info("connected", db=self.name)
 
 
-        async def insert(self, id: str, spider_name: str) -> None:
-            unique_id = f"{spider_name}_{id}"
-            timestamp = int(time.time())
-            await self.r.zadd(self._processed_ids_zset, {unique_id: timestamp})
-            self.logger.debug("inserted", id=unique_id, db=self.name)
-
-
-        async def exists(self, id: str, spider_name: str) -> bool:
+        async def insert(self, id: str, spider_name: str) -> bool:
             unique_id = f"{spider_name}_{id}"
-            score = await self.r.zscore(self._processed_ids_zset, unique_id)
-            return score is not None
-
-
-        async def delete(self, id: str, spider_name: str) -> None:
-            unique_id = f"{spider_name}_{id}"
-            await self.r.delete(unique_id)
-            self.logger.debug("deleted", id=unique_id, db=self.name)
-
-
-        async def cleanup(self, days: int) -> None:
-            threshold_timestamp = int(time.time()) - (days * 24 * 60 * 60)
-            await self.r.zremrangebyscore(self._processed_ids_zset, 0, threshold_timestamp)
+            result = await self.r.set(unique_id, 1, ex=self._record_expiry_sec, nx=True)
+            if result:
+                self.logger.debug("inserted", id=unique_id, db=self.name)
+                return True
+            else:
+                self.logger.debug("exists", id=unique_id, db=self.name)
+                return False
 
 
         async def close(self) -> None:
@@ -196,8 +157,5 @@ except ModuleNotFoundError:
         
         async def start(self) -> None: pass
         async def _connect(self) -> None: pass
-        async def insert(self, id: str, spider_name: str) -> None: pass
-        async def exists(self, id: str, spider_name: str) -> bool: return False
-        async def delete(self, id: str, spider_name: str) -> None: pass
-        async def cleanup(self, days: int) -> None: pass
+        async def insert(self, id: str, spider_name: str) -> bool: return False
         async def close(self) -> None: pass

{zenx-0.6.8 → zenx-0.7.0}/zenx/clients/http.py

@@ -1,7 +1,4 @@
 from __future__ import annotations
-import time
-import functools
-from collections import deque
 import parsel
 import random
 from curl_cffi.requests.impersonate import BrowserTypeLiteral
@@ -35,16 +32,6 @@ class Response:
         return sel
 
 
-def record_request(func):
-    @functools.wraps(func)
-    async def wrapper(self: HttpClient, *args, **kwargs) -> Response:
-        result = await func(self, *args, **kwargs)
-        self._requests_timestamps.append(time.time())
-        self._total_requests +=1
-        return result
-    return wrapper
-
-
 class HttpClient(ABC):
     # central registry
     name: ClassVar[str]
@@ -69,23 +56,7 @@ class HttpClient(ABC):
         self.logger = logger
         self.settings = settings
         self._session_pool: asyncio.Queue
-        # stats
-        self._requests_timestamps = deque()
-        self._total_requests = 0
     
-
-    def get_stats(self) -> Dict:
-        # calculate RPM based on rolling window of 1 min
-        now = time.time()
-        # remove requests older than 60 sec
-        while self._requests_timestamps and self._requests_timestamps[0] < (now - 60):
-            self._requests_timestamps.popleft()
-        rpm = len(self._requests_timestamps)
-        return {
-            "rpm": rpm,
-            "total_requests": self._total_requests,
-        }
-
     
     @abstractmethod
     async def request(
@@ -125,7 +96,6 @@ class CurlCffi(HttpClient):
         return chosen_fingerprint
 
     
-    @record_request
     async def request(
         self,
         url: str,

{zenx-0.6.8 → zenx-0.7.0}/zenx/engine.py

@@ -26,16 +26,6 @@ class Engine:
         self.shutdown_event.set()
 
 
-    async def _log_stats(self, spider: Spider) -> None:
-        while True:
-            await asyncio.sleep(60)
-            try:
-                rpm = spider.client.get_stats().get("rpm")
-                spider.logger.info("stats", rpm=rpm)
-            except asyncio.CancelledError:
-                break
-
-
     async def _execute(self, spider_name: str) -> None:
         loop = asyncio.get_running_loop()
         loop.add_signal_handler(signal.SIGINT, self._shutdown_handler)
@@ -57,8 +47,6 @@ class Engine:
         await pm.start_pipelines()
 
         spider = spider_cls(client=client, pm=pm, logger=logger, settings=settings)
-        
-        stats_task = asyncio.create_task(self._log_stats(spider))
         try:
             if self.forever:
                 while not self.shutdown_event.is_set():
@@ -72,15 +60,6 @@ class Engine:
         finally:
             if self.shutdown_event.is_set():
                 logger.info("shutdown", spider=spider_name)
-
-            stats_task.cancel()
-            try:
-                await stats_task
-            except asyncio.CancelledError:
-                pass
-            stats = spider.client.get_stats()
-            logger.info("summary", **stats)
-
             await client.close()
             await db.close()
             await pm.close_pipelines()

zenx-0.7.0/zenx/pipelines/manager.py

@@ -0,0 +1,44 @@
+import asyncio
+from typing import Dict, List
+from structlog import BoundLogger
+
+from zenx.exceptions import DropItem
+from zenx.pipelines.base import Pipeline
+from zenx.clients.database import DBClient
+from zenx.settings import Settings
+
+
+class PipelineManager:
+
+
+    def __init__(self, pipeline_names: List[str], logger: BoundLogger, db: DBClient, settings: Settings) -> None:
+        self.logger = logger
+        self.pipelines = {name:Pipeline.get_pipeline(name)(logger, db, settings) for name in pipeline_names}
+        self.settings = settings
+        self._fire_and_forget_pipelines = [p for p in self.pipelines.values() if p.name != "preprocess"]
+    
+    
+    async def start_pipelines(self) -> None:
+        """ connect and monitor """
+        for pipeline in self.pipelines.values():
+            await pipeline.start()
+            
+
+    async def process_item(self, item: Dict, spider: str) -> None:
+        preprocess_pipeline = self.pipelines.get("preprocess")
+        if preprocess_pipeline:
+            try:
+                item = await preprocess_pipeline.process_item(item, spider)
+            except DropItem:
+                self.logger.debug("dropped", id=item.get("_id"), pipeline=preprocess_pipeline.name)
+                return
+            except Exception:
+                self.logger.exception("process_item", item=item, pipeline=preprocess_pipeline.name)
+                raise
+        for pipeline in self._fire_and_forget_pipelines:
+            asyncio.create_task(pipeline.process_item(item, spider))
+
+    
+    async def close_pipelines(self) -> None:
+        for pipeline in self.pipelines.values():
+            await pipeline.close()

{zenx-0.6.8 → zenx-0.7.0}/zenx/settings.py

@@ -9,6 +9,7 @@ class Settings(BaseSettings):
     SESSION_POOL_SIZE: int = 1
     MAX_SCRAPE_DELAY: int = 10  # 10 seconds
     DQ_MAX_SIZE: int = 100  # max size of the deque for memory database
+    REDIS_RECORD_EXPIRY_SECONDS: int = 604800 # 7 days (7*24*60*60)
 
     DB_TYPE: Literal["memory", "redis"] = "memory"
     DB_NAME: str | None = None

{zenx-0.6.8 → zenx-0.7.0}/zenx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zenx
-Version: 0.6.8
+Version: 0.7.0
 Summary: mini-framework
 Requires-Python: >=3.12
 Requires-Dist: curl-cffi>=0.12.0

zenx-0.6.8/zenx/pipelines/manager.py

@@ -1,40 +0,0 @@
-from typing import Dict, List
-from structlog import BoundLogger
-
-from zenx.exceptions import DropItem
-from zenx.pipelines.base import Pipeline
-from zenx.clients.database import DBClient
-from zenx.settings import Settings
-
-
-class PipelineManager:
-
-
-    def __init__(self, pipeline_names: List[str], logger: BoundLogger, db: DBClient, settings: Settings) -> None:
-        self.logger = logger
-        self.pipelines = [Pipeline.get_pipeline(name)(logger, db, settings) for name in pipeline_names]
-        self.settings = settings
-    
-    
-    async def start_pipelines(self) -> None:
-        """ connect and monitor """
-        for pipeline in self.pipelines:
-            await pipeline.start()
-            
-
-    async def process_item(self, item: Dict, spider: str) -> Dict:
-        for pipeline in self.pipelines:
-            try:
-                item = await pipeline.process_item(item, spider)
-            except DropItem:
-                self.logger.debug("dropped", id=item.get("_id"))
-                break
-            except Exception:
-                self.logger.exception("process_item", pipeline=pipeline.name, item=item)
-                raise
-        return item
-
-    
-    async def close_pipelines(self) -> None:
-        for pipeline in self.pipelines:
-            await pipeline.close()