ysn-rfd/text-dataset-tiny-code-script-py-format

1# smart_context.py - اصلاح تابع retrieve_context
2
3async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
4    """بازیابی هوشمند context مرتبط با query"""
5    
6    if max_tokens is None:
7        max_tokens = self.max_context_tokens
8    
9    start_time = datetime.now()
10    
11    # 1. دریافت embedding برای query
12    query_embedding = self.embedding_manager.get_embedding(query)
13    
14    # 2. بازیابی از لایه‌های مختلف حافظه
15    retrieved_memories = []
16    
17    # از حافظه فعال (همیشه)
18    retrieved_memories.extend(self._retrieve_from_working_memory())
19    
20    # از حافظه اخیر (بر اساس شباهت)
21    recent_memories = await self._retrieve_semantic_memories(query_embedding, 'recent')
22    retrieved_memories.extend(recent_memories)
23    
24    # از حافظه بلندمدت (اطلاعات مهم)
25    long_term_memories = await self._retrieve_semantic_memories(query_embedding, 'long_term')
26    retrieved_memories.extend(long_term_memories)
27    
28    # از حافظه هسته (اطلاعات حیاتی کاربر)
29    core_memories = self._retrieve_core_memories(query)
30    retrieved_memories.extend(core_memories)
31    
32    # 3. حذف تکراری‌ها و مرتب‌سازی
33    unique_memories = self._deduplicate_memories(retrieved_memories)
34    prioritized_memories = self._prioritize_memories(unique_memories, query_embedding)
35    
36    # 4. انتخاب تا سقف توکن
37    final_context = []
38    total_tokens = 0
39    
40    for memory in prioritized_memories:
41        memory_tokens = memory['node'].tokens if 'node' in memory else 50
42        
43        if total_tokens + memory_tokens <= max_tokens:
44            final_context.append(memory)
45            total_tokens += memory_tokens
46        else:
47            break
48    
49    # 5. به‌روزرسانی آمار
50    self.stats['retrieved_memories'] += len(final_context)
51    
52    retrieval_time = (datetime.now() - start_time).total_seconds()
53    logger.info(f"Retrieved {len(final_context)} memories in {retrieval_time:.2f}s")
54    
55    return final_context
56
57# اصلاح تابع get_context_for_api
58async def get_context_for_api(self, query: str = None) -> List[Dict[str, Any]]:
59    """تهیه context برای ارسال به API"""
60    
61    # اگر query داریم، context هوشمند بازیابی کن
62    if query:
63        retrieved = await self.retrieve_context(query)
64        
65        # تبدیل به فرمت API
66        api_messages = []
67        
68        # ابتدا اطلاعات پروفایل کاربر
69        api_messages.append({
70            'role': 'system',
71            'content': f"User profile: {self._format_user_profile()}"
72        })
73        
74        # سپس حافظه‌های بازیابی شده
75        for memory in retrieved:
76            node = memory['node']
77            api_messages.append({
78                'role': node.role,
79                'content': node.content
80            })
81        
82        return api_messages
83    
84    else:
85        # حالت ساده: فقط حافظه فعال
86        api_messages = []
87        
88        for node in list(self.memory_layers['working'])[-6:]:
89            api_messages.append({
90                'role': node.role,
91                'content': node.content
92            })
93        
94        return api_messages
95    
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113# main.py - اصلاح تابع _process_user_request
114
115async def _process_user_request(update: Update, context: ContextTypes.DEFAULT_TYPE):
116    chat_id = update.effective_chat.id
117    user_message = update.message.text
118    user_id = update.effective_user.id
119    
120    start_time = time.time()
121
122    try:
123        await context.bot.send_chat_action(chat_id=chat_id, action="typing")
124        
125        # استفاده از Context هوشمند اگر فعال باشد
126        if HAS_SMART_CONTEXT:
127            smart_context = _get_or_create_smart_context(user_id)
128            
129            # پردازش پیام کاربر با سیستم هوشمند
130            await smart_context.process_message("user", user_message)
131            
132            # بازیابی context مرتبط
133            retrieved_context = await smart_context.retrieve_context(user_message, max_tokens=1024)
134            
135            # آماده‌سازی پیام‌ها برای API
136            messages = await smart_context.get_context_for_api(user_message)
137            
138            logger.info(f"Smart context: {len(messages)} messages retrieved for user {user_id}")
139        else:
140            # استفاده از سیستم قدیمی
141            user_context = data_manager.get_context_for_api(user_id)
142            data_manager.add_to_user_context(user_id, "user", user_message)
143            messages = user_context.copy()
144            messages.append({"role": "user", "content": user_message})
145        
146        # ارسال به API
147        response = await client.chat.completions.create(
148            model="mlabonne/gemma-3-27b-it-abliterated:featherless-ai",
149            messages=messages,
150            temperature=1.0,
151            top_p=0.95,
152            stream=False,
153        )
154        
155        end_time = time.time()
156        response_time = end_time - start_time
157        data_manager.update_response_stats(response_time)
158        
159        ai_response = response.choices[0].message.content
160        
161        # ذخیره پاسخ در سیستم مناسب
162        if HAS_SMART_CONTEXT:
163            await smart_context.process_message("assistant", ai_response)
164        else:
165            data_manager.add_to_user_context(user_id, "assistant", ai_response)
166        
167        await update.message.reply_text(ai_response)
168        data_manager.update_user_stats(user_id, update.effective_user)
169
170    except httpx.TimeoutException:
171        logger.warning(f"Request timed out for user {user_id}.")
172        await update.message.reply_text("⏱️ ارتباط با سرور هوش مصنوعی طولانی شد. لطفاً دوباره تلاش کنید.")
173    except Exception as e:
174        logger.error(f"Error while processing message for user {user_id}: {e}")
175        await update.message.reply_text("❌ متاسفانه در پردازش درخواست شما مشکلی پیش آمد. لطفاً دوباره تلاش کنید.")
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193# smart_context.py - اصلاح توابع async
194
195async def _retrieve_semantic_memories(self, query_embedding: np.ndarray, 
196                                    layer: str) -> List[Dict[str, Any]]:
197    """بازیابی حافظه‌های معنایی"""
198    memories = []
199    
200    if layer not in self.memory_layers:
201        return memories
202    
203    layer_memories = self.memory_layers[layer]
204    
205    for item in layer_memories:
206        node = item if hasattr(item, 'embeddings') else item['node'] if isinstance(item, dict) else None
207        
208        if node and node.embeddings is not None:
209            similarity = self.embedding_manager.cosine_similarity(
210                query_embedding, node.embeddings
211            )
212            
213            if similarity > self.semantic_similarity_threshold:
214                recency_weight = 1.0 if layer == 'working' else 0.7
215                
216                memories.append({
217                    'node': node,
218                    'source': layer,
219                    'relevance': similarity,
220                    'recency': recency_weight,
221                    'importance': node.importance_score
222                })
223    
224    return memories
225
226# اصلاح تابع process_message برای جلوگیری از block کردن
227async def process_message(self, role: str, content: str) -> Dict[str, Any]:
228    """پرداش کامل یک پیام جدید"""
229    start_time = datetime.now()
230    
231    # 1. تحلیل پیام
232    analysis = self.analyzer.analyze_message(content, role)
233    
234    # 2. ایجاد گره حافظه
235    message_id = self._generate_message_id(content)
236    
237    # ایجاد embedding به صورت غیرهمزمان
238    embedding_task = asyncio.create_task(
239        self._get_embedding_async(content)
240    )
241    
242    node = MessageNode(
243        id=message_id,
244        content=content,
245        role=role,
246        timestamp=datetime.now(),
247        message_type=analysis['type'],
248        importance_score=analysis['importance'],
249        emotion_score=analysis['emotion'],
250        tokens=data_manager.count_tokens(content),
251        embeddings=None,  # موقتاً None
252        metadata={
253            'analysis': analysis,
254            'topics': analysis['topics'],
255            'intent': analysis['intent'],
256            'complexity': analysis['complexity']
257        }
258    )
259    
260    # دریافت embedding (اگر موجود باشد)
261    try:
262        node.embeddings = await asyncio.wait_for(embedding_task, timeout=2.0)
263    except asyncio.TimeoutError:
264        logger.warning(f"Embedding generation timeout for message {message_id}")
265        node.embeddings = self.embedding_manager.get_embedding(content)
266    
267    # 3. افزودن به حافظه و گراف
268    await asyncio.to_thread(self._add_to_memory_layers, node, analysis)
269    await asyncio.to_thread(self.memory_graph.add_node, node)
270    
271    # 4. ایجاد ارتباطات
272    await asyncio.to_thread(self._create_memory_connections, node)
273    
274    # 5. به‌روزرسانی پروفایل کاربر
275    if role == 'user':
276        await asyncio.to_thread(self._update_user_profile, content, analysis)
277    
278    # 6. بهینه‌سازی حافظه
279    await asyncio.to_thread(self._optimize_memory)
280    
281    # 7. به‌روزرسانی آمار
282    self.stats['total_messages'] += 1
283    self.stats['average_importance'] = (
284        self.stats['average_importance'] * (self.stats['total_messages'] - 1) + 
285        analysis['importance']
286    ) / self.stats['total_messages']
287    
288    # 8. ذخیره داده‌ها
289    await asyncio.to_thread(self._save_data)
290    
291    processing_time = (datetime.now() - start_time).total_seconds()
292    logger.info(f"Processed message {message_id} in {processing_time:.2f}s, importance: {analysis['importance']:.2f}")
293    
294    return {
295        'node_id': message_id,
296        'analysis': analysis,
297        'processing_time': processing_time
298    }
299
300async def _get_embedding_async(self, text: str) -> np.ndarray:
301    """دریافت embedding به صورت async"""
302    loop = asyncio.get_event_loop()
303    return await loop.run_in_executor(
304        None, 
305        self.embedding_manager.get_embedding, 
306        text
307    )
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337# admin_panel.py - اصلاح توابع async در smart_context
338
339@admin_only
340async def admin_smart_context_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
341    """نمایش آمار context هوشمند برای کاربران"""
342    if not HAS_SMART_CONTEXT:
343        await update.message.reply_text("⚠️ سیستم context هوشمند فعال نیست.")
344        return
345    
346    if not context.args:
347        await update.message.reply_text("⚠️ لطفاً آیدی کاربر را وارد کنید.\nمثال: `/smart_stats 123456789`")
348        return
349    
350    user_id = int(context.args[0])
351    
352    # بررسی وجود مدیر context
353    if user_id not in smart_context_managers:
354        smart_context_managers[user_id] = IntelligentContextManager(user_id)
355    
356    smart_context = smart_context_managers[user_id]
357    summary = await asyncio.to_thread(smart_context.get_summary)
358    
359    # ... بقیه کد بدون تغییر
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387# smart_context.py - اضافه کردن خطاگیری بهتر
388
389async def retrieve_context(self, query: str, max_tokens: int = None) -> List[Dict[str, Any]]:
390    """بازیابی هوشمند context مرتبط با query"""
391    try:
392        if max_tokens is None:
393            max_tokens = self.max_context_tokens
394        
395        start_time = datetime.now()
396        
397        # دریافت embedding با timeout
398        try:
399            embedding_task = asyncio.create_task(
400                self._get_embedding_async(query)
401            )
402            query_embedding = await asyncio.wait_for(embedding_task, timeout=3.0)
403        except asyncio.TimeoutError:
404            logger.warning(f"Embedding timeout for query: {query[:50]}")
405            query_embedding = self.embedding_manager.get_embedding(query)
406        
407        # بازیابی از حافظه‌های مختلف به صورت موازی
408        tasks = []
409        
410        # حافظه فعال
411        tasks.append(asyncio.create_task(
412            asyncio.to_thread(self._retrieve_from_working_memory)
413        ))
414        
415        # حافظه معنایی
416        tasks.append(self._retrieve_semantic_memories(query_embedding, 'recent'))
417        tasks.append(self._retrieve_semantic_memories(query_embedding, 'long_term'))
418        
419        # حافظه هسته
420        tasks.append(asyncio.create_task(
421            asyncio.to_thread(self._retrieve_core_memories, query)
422        ))
423        
424        # اجرای موازی همه tasks
425        results = await asyncio.gather(*tasks, return_exceptions=True)
426        
427        # جمع‌آوری نتایج
428        retrieved_memories = []
429        for result in results:
430            if isinstance(result, Exception):
431                logger.error(f"Error retrieving memory: {result}")
432                continue
433            retrieved_memories.extend(result)
434        
435        # ادامه پردازش...
436        # ... بقیه کد بدون تغییر
437        
438    except Exception as e:
439        logger.error(f"Error in retrieve_context: {e}")
440        # Fallback: برگرداندن حافظه فعال
441        return self._retrieve_from_working_memory()