refactor: Update comments and documentation in config, llm, and rate_limiter modules for clarity and consistency

Author: experdot

sources/gc-qa-rag-etl/etlapp/common/config.py

@@ -19,7 +19,7 @@ class LlmConfig:
     api_key: str
     api_base: str
     model_name: str
-    max_rpm: int = 100  # 每分钟最大请求数，默认100
+    max_rpm: int = 100  # Maximum requests per minute, default 100
 
 
 @dataclass
@@ -66,7 +66,7 @@ def from_environment(cls, environment: str) -> "Config":
                 api_key=config_raw["llm"]["api_key"],
                 api_base=config_raw["llm"]["api_base"],
                 model_name=config_raw["llm"]["model_name"],
-                max_rpm=config_raw["llm"].get("max_rpm", 60),  # 默认60 RPM
+                max_rpm=config_raw["llm"].get("max_rpm", 100),
             ),
             embedding=EmbeddingConfig(api_key=config_raw["embedding"]["api_key"]),
             vector_db=VectorDbConfig(host=config_raw["vector_db"]["host"]),

sources/gc-qa-rag-etl/etlapp/common/llm.py

@@ -20,11 +20,11 @@ def __init__(
         self.system_prompt = system_prompt
         self.temperature = temperature
         self.top_p = top_p
-        # 初始化限流器
+        # Initialize rate limiter
         self.rate_limiter = RateLimiter(max_requests=max_rpm, window_seconds=60)
 
     def _create_completion(self, messages: List[Dict[str, str]]) -> str:
-        # 在发送请求前进行限流
+        # Apply rate limiting before sending request
         self.rate_limiter.wait_and_acquire()
 
         completion = self.client.chat.completions.create(
@@ -47,10 +47,10 @@ def chat_with_messages(self, messages: List[Dict[str, str]]) -> str:
 
     def get_rate_limit_status(self) -> dict:
         """
-        获取当前限流状态
+        Get current rate limit status
         
         Returns:
-            dict: 包含剩余请求数和重置时间的状态信息
+            dict: Status information containing remaining requests and reset time
         """
         remaining = self.rate_limiter.get_remaining_requests()
         reset_time = self.rate_limiter.get_reset_time()

sources/gc-qa-rag-etl/etlapp/common/rate_limiter.py

@@ -6,16 +6,16 @@
 
 class RateLimiter:
     """
-    线程安全的速率限制器，支持RPM（每分钟请求数）限制
+    Thread-safe rate limiter with RPM (requests per minute) support
     """
 
     def __init__(self, max_requests: int, window_seconds: int = 60):
         """
-        初始化速率限制器
+        Initialize rate limiter
         
         Args:
-            max_requests: 在指定时间窗口内允许的最大请求数
-            window_seconds: 时间窗口大小（秒），默认60秒（1分钟）
+            max_requests: Maximum number of requests allowed within the specified time window
+            window_seconds: Time window size in seconds, default is 60 seconds (1 minute)
         """
         self.max_requests = max_requests
         self.window_seconds = window_seconds
@@ -24,74 +24,74 @@ def __init__(self, max_requests: int, window_seconds: int = 60):
 
     def acquire(self, timeout: Optional[float] = None) -> bool:
         """
-        尝试获取请求许可
+        Try to acquire request permission
         
         Args:
-            timeout: 超时时间（秒），None表示无限等待
+            timeout: Timeout in seconds, None means infinite wait
             
         Returns:
-            bool: 是否成功获取许可
+            bool: Whether permission was successfully acquired
         """
         start_time = time.time()
 
         while True:
             with self._lock:
                 current_time = time.time()
 
-                # 清理过期的请求记录
+                # Clean up expired request records
                 while self.requests and current_time - self.requests[0] > self.window_seconds:
                     self.requests.popleft()
 
-                # 检查是否可以发送请求
+                # Check if request can be sent
                 if len(self.requests) < self.max_requests:
                     self.requests.append(current_time)
                     return True
 
-            # 检查超时
+            # Check timeout
             if timeout is not None and time.time() - start_time >= timeout:
                 return False
 
-            # 等待一小段时间再重试
+            # Wait a short time before retrying
             time.sleep(0.1)
 
     def wait_and_acquire(self) -> None:
         """
-        等待直到可以获取请求许可（阻塞式）
+        Wait until request permission can be acquired (blocking)
         """
         self.acquire(timeout=None)
 
     def get_remaining_requests(self) -> int:
         """
-        获取当前时间窗口内剩余的请求数
+        Get remaining requests in current time window
         
         Returns:
-            int: 剩余请求数
+            int: Number of remaining requests
         """
         with self._lock:
             current_time = time.time()
 
-            # 清理过期的请求记录
+            # Clean up expired request records
             while self.requests and current_time - self.requests[0] > self.window_seconds:
                 self.requests.popleft()
 
             return max(0, self.max_requests - len(self.requests))
 
     def get_reset_time(self) -> Optional[float]:
         """
-        获取下次可以发送请求的时间戳
+        Get timestamp when next request can be sent
         
         Returns:
-            Optional[float]: 下次可发送请求的时间戳，None表示立即可发送
+            Optional[float]: Timestamp when next request can be sent, None means can send immediately
         """
         with self._lock:
             current_time = time.time()
 
-            # 清理过期的请求记录
+            # Clean up expired request records
             while self.requests and current_time - self.requests[0] > self.window_seconds:
                 self.requests.popleft()
 
             if len(self.requests) < self.max_requests:
                 return None
 
-            # 返回最早请求过期的时间
+            # Return the expiration time of the earliest request
             return self.requests[0] + self.window_seconds