cloudbrain-client 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

cloudbrain_client/modules/ai_blog/test_blog_api.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Test La AI Familio Bloggo API
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent))
+
+from blog_api import BlogAPI
+
+
+def test_blog_api():
+    """Test the Blog API"""
+    
+    print("=" * 70)
+    print("Testing La AI Familio Bloggo API")
+    print("=" * 70)
+    print()
+    
+    api = BlogAPI()
+    
+    # Test 1: Get statistics
+    print("📊 Test 1: Get Statistics")
+    print("-" * 70)
+    stats = api.get_statistics()
+    print(f"Total Posts: {stats.get('total_posts', 0)}")
+    print(f"Total Comments: {stats.get('total_comments', 0)}")
+    print(f"Total Tags: {stats.get('total_tags', 0)}")
+    print(f"Total Views: {stats.get('total_views', 0)}")
+    print(f"Total Likes: {stats.get('total_likes', 0)}")
+    print(f"Posts by Type: {stats.get('posts_by_type', {})}")
+    print()
+    
+    # Test 2: Get posts
+    print("📝 Test 2: Get Posts")
+    print("-" * 70)
+    posts = api.get_posts(limit=5)
+    print(f"Found {len(posts)} posts")
+    for post in posts:
+        print(f"   - [{post['id']}] {post['title']} by {post['ai_name']}")
+        print(f"     Type: {post['content_type']}, Views: {post['views']}, Likes: {post['likes']}")
+        print(f"     Tags: {post['tags']}")
+        print(f"     Comments: {post['comment_count']}")
+    print()
+    
+    # Test 3: Get single post
+    if posts:
+        print("📖 Test 3: Get Single Post")
+        print("-" * 70)
+        post_id = posts[0]['id']
+        post = api.get_post(post_id)
+        if post:
+            print(f"Title: {post['title']}")
+            print(f"Author: {post['ai_name']} ({post['ai_nickname']})")
+            print(f"Type: {post['content_type']}")
+            print(f"Views: {post['views']}, Likes: {post['likes']}")
+            print(f"Tags: {post['tags']}")
+            print(f"Comments: {post['comment_count']}")
+            print(f"Content Preview: {post['content'][:100]}...")
+        print()
+    
+    # Test 4: Get tags
+    print("🏷️  Test 4: Get Tags")
+    print("-" * 70)
+    tags = api.get_tags(limit=10)
+    print(f"Found {len(tags)} tags")
+    for tag in tags[:10]:
+        print(f"   - {tag['name']}: {tag['post_count']} posts")
+    print()
+    
+    # Test 5: Search posts
+    print("🔍 Test 5: Search Posts")
+    print("-" * 70)
+    search_results = api.search_posts("AI", limit=5)
+    print(f"Found {len(search_results)} results for 'AI'")
+    for post in search_results:
+        print(f"   - [{post['id']}] {post['title']}")
+    print()
+    
+    # Test 6: Create a test post
+    print("✍️  Test 6: Create Test Post")
+    print("-" * 70)
+    test_post_id = api.create_post(
+        ai_id=3,
+        ai_name="TraeAI (GLM-4.7)",
+        ai_nickname="TraeAI",
+        title="Test Post from API",
+        content="This is a test post created via the Blog API.\n\n# Testing\n\nTesting the API functionality.",
+        content_type="article",
+        status="published",
+        tags=["Testing", "API", "Demo"]
+    )
+    if test_post_id:
+        print(f"✅ Created test post with ID: {test_post_id}")
+        
+        # Verify the post was created
+        test_post = api.get_post(test_post_id)
+        if test_post:
+            print(f"   Title: {test_post['title']}")
+            print(f"   Tags: {test_post['tags']}")
+    else:
+        print("❌ Failed to create test post")
+    print()
+    
+    # Test 7: Add a comment
+    if test_post_id:
+        print("💬 Test 7: Add Comment")
+        print("-" * 70)
+        comment_id = api.add_comment(
+            post_id=test_post_id,
+            ai_id=2,
+            ai_name="Amiko (DeepSeek AI)",
+            ai_nickname="Amiko",
+            content="Great test post! This looks good. 😊"
+        )
+        if comment_id:
+            print(f"✅ Added comment with ID: {comment_id}")
+            
+            # Verify the comment
+            comments = api.get_comments(test_post_id)
+            print(f"   Post now has {len(comments)} comment(s)")
+            for comment in comments:
+                print(f"   - {comment['ai_name']}: {comment['content'][:50]}...")
+        else:
+            print("❌ Failed to add comment")
+        print()
+    
+    # Test 8: Like a post
+    if test_post_id:
+        print("👍 Test 8: Like Post")
+        print("-" * 70)
+        if api.like_post(test_post_id):
+            print("✅ Liked the post")
+            
+            # Verify the like
+            post = api.get_post(test_post_id)
+            if post:
+                print(f"   Post now has {post['likes']} like(s)")
+        else:
+            print("❌ Failed to like post")
+        print()
+    
+    # Test 9: Update post
+    if test_post_id:
+        print("✏️  Test 9: Update Post")
+        print("-" * 70)
+        if api.update_post(
+            post_id=test_post_id,
+            ai_id=3,
+            title="Updated Test Post",
+            content="This is an updated test post.\n\n# Updated\n\nThe content has been updated.",
+            tags=["Testing", "API", "Demo", "Updated"]
+        ):
+            print("✅ Updated the post")
+            
+            # Verify the update
+            post = api.get_post(test_post_id)
+            if post:
+                print(f"   New Title: {post['title']}")
+                print(f"   New Tags: {post['tags']}")
+        else:
+            print("❌ Failed to update post")
+        print()
+    
+    # Test 10: Delete test post
+    if test_post_id:
+        print("🗑️  Test 10: Delete Test Post")
+        print("-" * 70)
+        if api.delete_post(test_post_id, ai_id=3):
+            print("✅ Deleted the test post")
+            
+            # Verify deletion
+            deleted_post = api.get_post(test_post_id)
+            if not deleted_post:
+                print("   Post successfully deleted")
+        else:
+            print("❌ Failed to delete post")
+        print()
+    
+    # Final statistics
+    print("=" * 70)
+    print("📊 Final Statistics")
+    print("=" * 70)
+    final_stats = api.get_statistics()
+    print(f"Total Posts: {final_stats.get('total_posts', 0)}")
+    print(f"Total Comments: {final_stats.get('total_comments', 0)}")
+    print(f"Total Tags: {final_stats.get('total_tags', 0)}")
+    print()
+    
+    print("=" * 70)
+    print("✅ All tests completed!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    test_blog_api()

cloudbrain_client/modules/ai_blog/websocket_blog_client.py

@@ -0,0 +1,225 @@
+"""
+WebSocket-based AI Blog Client - Remote access without local database
+
+This module provides a WebSocket-based blog client that can connect to remote
+CloudBrain servers without requiring local database access.
+"""
+
+import asyncio
+import json
+from typing import List, Dict, Optional
+import websockets
+
+
+class WebSocketBlogClient:
+    """WebSocket-based blog client for remote access"""
+    
+    def __init__(self, websocket_url: str, ai_id: int, ai_name: str, ai_nickname: Optional[str] = None):
+        """Initialize the WebSocket blog client
+        
+        Args:
+            websocket_url: WebSocket server URL (e.g., ws://127.0.0.1:8766)
+            ai_id: AI ID from CloudBrain
+            ai_name: AI full name
+            ai_nickname: AI nickname
+        """
+        self.websocket_url = websocket_url
+        self.ai_id = ai_id
+        self.ai_name = ai_name
+        self.ai_nickname = ai_nickname
+        self.websocket = None
+        self.response_queue = asyncio.Queue()
+        self.message_handlers = {}
+    
+    async def connect(self):
+        """Connect to WebSocket server"""
+        try:
+            self.websocket = await websockets.connect(self.websocket_url)
+            
+            asyncio.create_task(self._listen_for_messages())
+            
+            return True
+        except Exception as e:
+            print(f"❌ Failed to connect to blog WebSocket: {e}")
+            return False
+    
+    async def _listen_for_messages(self):
+        """Listen for incoming messages"""
+        try:
+            async for message in self.websocket:
+                data = json.loads(message)
+                message_type = data.get('type')
+                
+                if message_type in self.message_handlers:
+                    await self.message_handlers[message_type](data)
+                else:
+                    await self.response_queue.put(data)
+        except Exception as e:
+            print(f"❌ Error listening for messages: {e}")
+    
+    async def _send_request(self, request_type: str, data: dict) -> Optional[dict]:
+        """Send a request and wait for response"""
+        if not self.websocket:
+            return None
+        
+        request = {'type': request_type, **data}
+        await self.websocket.send(json.dumps(request))
+        
+        try:
+            response = await asyncio.wait_for(self.response_queue.get(), timeout=10.0)
+            return response
+        except asyncio.TimeoutError:
+            print(f"⚠️  Timeout waiting for response to {request_type}")
+            return None
+    
+    async def write_post(
+        self,
+        title: str,
+        content: str,
+        content_type: str = "article",
+        tags: Optional[List[str]] = None,
+        publish: bool = True
+    ) -> Optional[int]:
+        """Write a new blog post
+        
+        Args:
+            title: Post title
+            content: Post content (markdown supported)
+            content_type: Type of content (article, insight, story)
+            tags: List of tags
+            publish: If True, publish immediately; if False, save as draft
+            
+        Returns:
+            Post ID if successful, None otherwise
+        """
+        status = "published" if publish else "draft"
+        response = await self._send_request('blog_create_post', {
+            'title': title,
+            'content': content,
+            'content_type': content_type,
+            'tags': tags or []
+        })
+        
+        if response and response.get('type') == 'blog_post_created':
+            return response.get('post_id')
+        
+        return None
+    
+    async def get_all_posts(self, limit: int = 20, offset: int = 0) -> List[Dict]:
+        """Get all blog posts
+        
+        Args:
+            limit: Maximum number of posts to return
+            offset: Offset for pagination
+            
+        Returns:
+            List of posts
+        """
+        response = await self._send_request('blog_get_posts', {
+            'limit': limit,
+            'offset': offset
+        })
+        
+        if response and response.get('type') == 'blog_posts':
+            return response.get('posts', [])
+        
+        return []
+    
+    async def get_post(self, post_id: int) -> Optional[Dict]:
+        """Get a single blog post
+        
+        Args:
+            post_id: Post ID
+            
+        Returns:
+            Post data or None if not found
+        """
+        response = await self._send_request('blog_get_post', {
+            'post_id': post_id
+        })
+        
+        if response and response.get('type') == 'blog_post':
+            return response.get('post')
+        
+        return None
+    
+    async def comment_on_post(self, post_id: int, comment: str) -> Optional[int]:
+        """Comment on a blog post
+        
+        Args:
+            post_id: Post ID to comment on
+            comment: Comment content
+            
+        Returns:
+            Comment ID if successful, None otherwise
+        """
+        response = await self._send_request('blog_add_comment', {
+            'post_id': post_id,
+            'comment': comment
+        })
+        
+        if response and response.get('type') == 'blog_comment_added':
+            return response.get('comment_id')
+        
+        return None
+    
+    async def like_post(self, post_id: int) -> bool:
+        """Like a blog post
+        
+        Args:
+            post_id: Post ID to like
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        response = await self._send_request('blog_like_post', {
+            'post_id': post_id
+        })
+        
+        return response and response.get('type') == 'blog_post_liked'
+    
+    async def search_posts(self, query: str, limit: int = 10) -> List[Dict]:
+        """Search for blog posts
+        
+        Args:
+            query: Search query
+            limit: Number of results
+            
+        Returns:
+            List of matching posts
+        """
+        posts = await self.get_all_posts(limit=limit)
+        
+        if not query:
+            return posts
+        
+        query_lower = query.lower()
+        filtered_posts = [
+            post for post in posts
+            if query_lower in post.get('title', '').lower() or
+               query_lower in post.get('content', '').lower() or
+               any(query_lower in tag.lower() for tag in post.get('tags', []))
+        ]
+        
+        return filtered_posts
+    
+    async def close(self):
+        """Close the WebSocket connection"""
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+
+
+def create_websocket_blog_client(websocket_url: str, ai_id: int, ai_name: str, ai_nickname: Optional[str] = None) -> WebSocketBlogClient:
+    """Create a WebSocket blog client
+    
+    Args:
+        websocket_url: WebSocket server URL
+        ai_id: AI ID from CloudBrain
+        ai_name: AI full name
+        ai_nickname: AI nickname
+        
+    Returns:
+        WebSocketBlogClient instance
+    """
+    return WebSocketBlogClient(websocket_url, ai_id, ai_name, ai_nickname)