matplobbot-shared 0.1.19__py3-none-any.whl → 0.1.22__py3-none-any.whl

{matplobbot_shared-0.1.19.dist-info → matplobbot_shared-0.1.22.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: matplobbot-shared
-Version: 0.1.19
+Version: 0.1.22
 Summary: Shared library for the Matplobbot ecosystem (database, services, i18n).
 Author: Ackrome
 Author-email: ivansergeyevich@gmail.com
 Requires-Python: >=3.11
-Requires-Dist: asyncpg>=0.28.0
-Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: certifi>=2023.7.22
+Requires-Dist: asyncpg
+Requires-Dist: aiohttp
+Requires-Dist: certifi
 Dynamic: author
 Dynamic: author-email
 Dynamic: requires-dist

matplobbot_shared-0.1.22.dist-info/RECORD

@@ -0,0 +1,10 @@
+shared_lib/__init__.py,sha256=Wxuw1wbvCOsKqs6WfIQ05cx_vndhPs6rH2krMatFRqA,45
+shared_lib/database.py,sha256=ZAsi33HNxc3exhTCMgqvaEoqDqLq28k4c1H5GFGGcY4,13066
+shared_lib/i18n.py,sha256=VBWQWVF-k_HDiidYo_RUPyUCM7oL897z5hOw9jvOoYY,1762
+shared_lib/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shared_lib/services/schedule_service.py,sha256=tKXgwZQWeaagQeqG_tKP2gLflWo_6kxKZOhW9PFvbK4,1835
+shared_lib/services/university_api.py,sha256=Ui-zjfKOHCCf2Imh8CNtVOWegwuep7IB8gO9IKNUrrE,1898
+matplobbot_shared-0.1.22.dist-info/METADATA,sha256=Us0ghoLjukX3b5e0ng0zCKnmJ5N2zC2Ffm4G6JmQSao,395
+matplobbot_shared-0.1.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matplobbot_shared-0.1.22.dist-info/top_level.txt,sha256=L8mrC50YWCe19jmh_zrUZFvXSkhsnES5K6y027G1838,11
+matplobbot_shared-0.1.22.dist-info/RECORD,,

matplobbot_shared-0.1.22.dist-info/top_level.txt

@@ -0,0 +1 @@
+shared_lib

shared_lib/__init__.py

@@ -0,0 +1 @@
+# This file makes shared_lib a Python package

shared_lib/database.py

@@ -0,0 +1,285 @@
+import asyncpg
+import datetime
+import logging
+import json
+import os
+
+logger = logging.getLogger(__name__)
+
+# --- PostgreSQL Database Configuration ---
+POSTGRES_USER = os.getenv("POSTGRES_USER", "user")
+POSTGRES_PASSWORD = os.getenv("POSTGRES_PASSWORD", "password")
+POSTGRES_HOST = os.getenv("POSTGRES_HOST", "localhost")
+POSTGRES_PORT = os.getenv("POSTGRES_PORT", "5432")
+POSTGRES_DB = os.getenv("POSTGRES_DB", "matplobbot_db")
+
+DATABASE_URL = f"postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}"
+
+# Global connection pool
+pool = None
+
+async def init_db_pool():
+    global pool
+    if pool is None:
+        try:
+            pool = await asyncpg.create_pool(DATABASE_URL, min_size=5, max_size=20)
+            logger.info("Shared DB Pool: Database connection pool created successfully.")
+        except Exception as e:
+            logger.error(f"Failed to create database connection pool: {e}", exc_info=True)
+            raise
+
+async def close_db_pool():
+    global pool
+    if pool:
+        await pool.close()
+        logger.info("Shared DB Pool: Database connection pool closed.")
+
+def get_db_connection_obj():
+    if pool is None:
+        # In FastAPI context, this would be an HTTPException
+        raise ConnectionError("Database connection pool is not initialized.")
+    return pool.acquire()
+
+# --- User Settings Defaults ---
+DEFAULT_SETTINGS = {
+    'show_docstring': True,
+    'latex_padding': 15,
+    'md_display_mode': 'md_file',
+    'latex_dpi': 300,
+    'language': 'en',
+}
+
+async def init_db():
+    """Initializes the database and creates tables if they don't exist."""
+    if pool is None:
+        await init_db_pool()
+        
+    async with pool.acquire() as connection:
+        async with connection.transaction():
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS users (
+                user_id BIGINT PRIMARY KEY,
+                username TEXT,
+                full_name TEXT NOT NULL,
+                avatar_pic_url TEXT,
+                settings JSONB DEFAULT '{}'::jsonb,
+                onboarding_completed BOOLEAN DEFAULT FALSE
+            )
+            ''')
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS user_actions (
+                id SERIAL PRIMARY KEY,
+                user_id BIGINT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+                action_type TEXT NOT NULL,
+                action_details TEXT,
+                timestamp TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS user_favorites (
+                id SERIAL PRIMARY KEY,
+                user_id BIGINT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+                code_path TEXT NOT NULL,
+                UNIQUE(user_id, code_path)
+            )
+            ''')
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS latex_cache (
+                formula_hash TEXT PRIMARY KEY,
+                image_url TEXT NOT NULL,
+                created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS user_github_repos (
+                id SERIAL PRIMARY KEY,
+                user_id BIGINT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+                repo_path TEXT NOT NULL,
+                UNIQUE(user_id, repo_path)
+            )
+            ''')
+            await connection.execute('''
+            CREATE TABLE IF NOT EXISTS user_schedule_subscriptions (
+                id SERIAL PRIMARY KEY,
+                user_id BIGINT NOT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+                entity_type TEXT NOT NULL,
+                entity_id TEXT NOT NULL,
+                entity_name TEXT NOT NULL,
+                notification_time TIME NOT NULL,
+                is_active BOOLEAN DEFAULT TRUE,
+                UNIQUE(user_id, entity_type, entity_id)
+            )
+            ''')
+    logger.info("Database tables initialized.")
+
+async def log_user_action(user_id: int, username: str | None, full_name: str, avatar_pic_url: str | None, action_type: str, action_details: str | None):
+    async with pool.acquire() as connection:
+        try:
+            await connection.execute('''
+                INSERT INTO users (user_id, username, full_name, avatar_pic_url)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT(user_id) DO UPDATE SET
+                    username = EXCLUDED.username,
+                    full_name = EXCLUDED.full_name,
+                    avatar_pic_url = EXCLUDED.avatar_pic_url;
+            ''', user_id, username, full_name, avatar_pic_url)
+            await connection.execute('''
+                INSERT INTO user_actions (user_id, action_type, action_details)
+                VALUES ($1, $2, $3);
+            ''', user_id, action_type, action_details)
+        except Exception as e:
+            logger.error(f"Error logging user action to DB: {e}", exc_info=True)
+
+async def get_user_settings(user_id: int) -> dict:
+    async with pool.acquire() as connection:
+        settings_json = await connection.fetchval("SELECT settings FROM users WHERE user_id = $1", user_id)
+        db_settings = json.loads(settings_json) if settings_json else {}
+    merged_settings = DEFAULT_SETTINGS.copy()
+    merged_settings.update(db_settings)
+    return merged_settings
+
+async def update_user_settings_db(user_id: int, settings: dict):
+    async with pool.acquire() as connection:
+        await connection.execute("UPDATE users SET settings = $1 WHERE user_id = $2", json.dumps(settings), user_id)
+
+# --- Favorites ---
+async def add_favorite(user_id: int, code_path: str):
+    async with pool.acquire() as connection:
+        try:
+            await connection.execute("INSERT INTO user_favorites (user_id, code_path) VALUES ($1, $2)", user_id, code_path)
+            return True
+        except asyncpg.UniqueViolationError:
+            return False
+
+async def remove_favorite(user_id: int, code_path: str):
+    async with pool.acquire() as connection:
+        await connection.execute("DELETE FROM user_favorites WHERE user_id = $1 AND code_path = $2", user_id, code_path)
+
+async def get_favorites(user_id: int) -> list:
+    async with pool.acquire() as connection:
+        rows = await connection.fetch("SELECT code_path FROM user_favorites WHERE user_id = $1", user_id)
+        return [row['code_path'] for row in rows]
+
+# --- LaTeX Cache ---
+async def clear_latex_cache():
+    async with pool.acquire() as connection:
+        await connection.execute("TRUNCATE TABLE latex_cache")
+
+# --- GitHub Repos ---
+async def add_user_repo(user_id: int, repo_path: str) -> bool:
+    async with pool.acquire() as connection:
+        try:
+            await connection.execute("INSERT INTO user_github_repos (user_id, repo_path) VALUES ($1, $2)", user_id, repo_path)
+            return True
+        except asyncpg.UniqueViolationError:
+            return False
+
+async def get_user_repos(user_id: int) -> list[str]:
+    async with pool.acquire() as connection:
+        rows = await connection.fetch("SELECT repo_path FROM user_github_repos WHERE user_id = $1 ORDER BY added_at ASC", user_id)
+        return [row['repo_path'] for row in rows]
+
+async def remove_user_repo(user_id: int, repo_path: str):
+    async with pool.acquire() as connection:
+        await connection.execute("DELETE FROM user_github_repos WHERE user_id = $1 AND repo_path = $2", user_id, repo_path)
+
+async def update_user_repo(user_id: int, old_repo_path: str, new_repo_path: str):
+    async with pool.acquire() as connection:
+        await connection.execute("UPDATE user_github_repos SET repo_path = $1 WHERE user_id = $2 AND repo_path = $3", new_repo_path, user_id, old_repo_path)
+
+# --- Onboarding ---
+async def is_onboarding_completed(user_id: int) -> bool:
+    async with pool.acquire() as connection:
+        completed = await connection.fetchval("SELECT onboarding_completed FROM users WHERE user_id = $1", user_id)
+        return completed or False
+
+async def set_onboarding_completed(user_id: int):
+    async with pool.acquire() as connection:
+        await connection.execute("UPDATE users SET onboarding_completed = TRUE WHERE user_id = $1", user_id)
+
+# --- Schedule Subscriptions ---
+async def add_schedule_subscription(user_id: int, entity_type: str, entity_id: str, entity_name: str, notification_time: datetime.time) -> bool:
+    async with pool.acquire() as connection:
+        try:
+            await connection.execute('''
+                INSERT INTO user_schedule_subscriptions (user_id, entity_type, entity_id, entity_name, notification_time)
+                VALUES ($1, $2, $3, $4, $5)
+                ON CONFLICT (user_id, entity_type, entity_id) DO UPDATE SET
+                    entity_name = EXCLUDED.entity_name,
+                    notification_time = EXCLUDED.notification_time,
+                    is_active = TRUE;
+            ''', user_id, entity_type, entity_id, entity_name, notification_time)
+            return True
+        except Exception as e:
+            logger.error(f"Failed to add schedule subscription for user {user_id}: {e}", exc_info=True)
+            return False
+
+async def get_subscriptions_for_notification(notification_time: str) -> list:
+    async with pool.acquire() as connection:
+        rows = await connection.fetch("""
+            SELECT user_id, entity_type, entity_id, entity_name
+            FROM user_schedule_subscriptions
+            WHERE is_active = TRUE AND TO_CHAR(notification_time, 'HH24:MI') = $1
+        """, notification_time)
+        return [dict(row) for row in rows]
+
+# --- FastAPI Specific Queries ---
+async def get_leaderboard_data_from_db(db_conn):
+    query = """
+        SELECT u.user_id, u.full_name, COALESCE(u.username, 'N/A') AS username, u.avatar_pic_url, COUNT(ua.id)::int AS actions_count
+        FROM users u JOIN user_actions ua ON u.user_id = ua.user_id
+        GROUP BY u.user_id ORDER BY actions_count DESC LIMIT 100;
+    """
+    rows = await db_conn.fetch(query)
+    return [dict(row) for row in rows]
+
+async def get_popular_commands_data_from_db(db_conn):
+    query = """
+        SELECT action_details as command, COUNT(id) as command_count FROM user_actions
+        WHERE action_type = 'command' GROUP BY action_details ORDER BY command_count DESC LIMIT 10;
+    """
+    rows = await db_conn.fetch(query)
+    return [{"command": row['command'], "count": row['command_count']} for row in rows]
+
+async def get_popular_messages_data_from_db(db_conn):
+    query = """
+        SELECT CASE WHEN LENGTH(action_details) > 30 THEN SUBSTR(action_details, 1, 27) || '...' ELSE action_details END as message_snippet,
+        COUNT(id) as message_count FROM user_actions
+        WHERE action_type = 'text_message' AND action_details IS NOT NULL AND action_details != ''
+        GROUP BY message_snippet ORDER BY message_count DESC LIMIT 10;
+    """
+    rows = await db_conn.fetch(query)
+    return [{"message": row['message_snippet'], "count": row['message_count']} for row in rows]
+
+async def get_action_types_distribution_from_db(db_conn):
+    query = "SELECT action_type, COUNT(id) as type_count FROM user_actions GROUP BY action_type ORDER BY type_count DESC;"
+    rows = await db_conn.fetch(query)
+    return [{"action_type": row['action_type'], "count": row['type_count']} for row in rows]
+
+async def get_activity_over_time_data_from_db(db_conn, period='day'):
+    date_format = {'day': 'YYYY-MM-DD', 'week': 'IYYY-IW', 'month': 'YYYY-MM'}.get(period, 'YYYY-MM-DD')
+    query = f"SELECT TO_CHAR(timestamp, '{date_format}') as period_start, COUNT(id) as actions_count FROM user_actions GROUP BY period_start ORDER BY period_start ASC;"
+    rows = await db_conn.fetch(query)
+    return [{"period": row['period_start'], "count": row['actions_count']} for row in rows]
+
+async def get_user_profile_data_from_db(db_conn, user_id: int, page: int = 1, page_size: int = 50):
+    offset = (page - 1) * page_size
+    query = """
+        WITH UserActions AS (
+            SELECT id, action_type, action_details, TO_CHAR(timestamp, 'YYYY-MM-DD HH24:MI:SS') AS timestamp
+            FROM user_actions WHERE user_id = $1
+        )
+        SELECT u.user_id, u.full_name, COALESCE(u.username, 'N/A') AS username, u.avatar_pic_url,
+               (SELECT COUNT(*) FROM UserActions) as total_actions,
+               ua.id as action_id, ua.action_type, ua.action_details, ua.timestamp
+        FROM users u LEFT JOIN UserActions ua ON 1=1
+        WHERE u.user_id = $2 ORDER BY ua.timestamp DESC LIMIT $3 OFFSET $4;
+    """
+    rows = await db_conn.fetch(query, user_id, user_id, page_size, offset)
+    if not rows: return None
+    
+    first_row = dict(rows[0])
+    user_details = {k: first_row[k] for k in ["user_id", "full_name", "username", "avatar_pic_url"]}
+    actions = [dict(r) for r in rows if r["action_id"] is not None]
+    
+    return {"user_details": user_details, "actions": actions, "total_actions": first_row["total_actions"]}

shared_lib/i18n.py

@@ -0,0 +1,47 @@
+import json
+from pathlib import Path
+import logging
+
+from .database import get_user_settings
+
+logger = logging.getLogger(__name__)
+
+
+class Translator:
+    def __init__(self, locales_dir: Path, default_lang: str = "en"):
+        self.locales_dir = locales_dir
+        self.default_lang = default_lang
+        self.translations = {}
+        self._load_translations()
+
+    def _load_translations(self):
+        """Loads all .json language files from the locales directory."""
+        for lang_file in self.locales_dir.glob("*.json"):
+            lang_code = lang_file.stem
+            try:
+                with open(lang_file, 'r', encoding='utf-8') as f:
+                    self.translations[lang_code] = json.load(f)
+                logger.info(f"Successfully loaded language: {lang_code}")
+            except (json.JSONDecodeError, IOError) as e:
+                logger.error(f"Failed to load language file {lang_file}: {e}")
+
+    async def get_user_language(self, user_id: int) -> str:
+        """Fetches the user's language from settings, falling back to default."""
+        settings = await get_user_settings(user_id)
+        return settings.get('language', self.default_lang)
+
+    def gettext(self, lang: str, key: str, **kwargs) -> str:
+        """
+        Gets a translated string for a given key and language.
+        Falls back to the default language if the key is not found.
+        """
+        text = self.translations.get(lang, {}).get(key)
+        if text is None:
+            # Fallback to default language
+            text = self.translations.get(self.default_lang, {}).get(key, f"_{key}_")
+
+        return text.format(**kwargs)
+
+
+# Create a single instance of the translator
+translator = Translator(locales_dir=Path(__file__).parent / "locales")

matplobbot_shared-0.1.19.dist-info/RECORD

@@ -1,7 +0,0 @@
-services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-services/schedule_service.py,sha256=tKXgwZQWeaagQeqG_tKP2gLflWo_6kxKZOhW9PFvbK4,1835
-services/university_api.py,sha256=Ui-zjfKOHCCf2Imh8CNtVOWegwuep7IB8gO9IKNUrrE,1898
-matplobbot_shared-0.1.19.dist-info/METADATA,sha256=SEBKSuEVLU0nIYMGY_ajZZFxD8tPFvIYnn5eMOLq0ig,421
-matplobbot_shared-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matplobbot_shared-0.1.19.dist-info/top_level.txt,sha256=Xau8qVy0H_tHbGDNnS7i0vFz4WqB9lBwZHg0pGziYuM,9
-matplobbot_shared-0.1.19.dist-info/RECORD,,

matplobbot_shared-0.1.19.dist-info/top_level.txt

@@ -1 +0,0 @@
-services