UAForge 1.1.0__py3-none-any.whl

uaforge/__init__.py

@@ -0,0 +1,128 @@
+from .core.user_agent import UserAgentGenerator
+from .core.database import Database
+from .core.version_fetcher import VersionFetcher
+from .core.version_updater import VersionUpdater
+
+__version__ = "1.1.0"
+__author__ = "bolgac"
+__email__ = "bytearchsoft@gmail.com"
+
+__all__ = ['UserAgentGenerator', 'Database', 'VersionFetcher', 'VersionUpdater']
+
+def init_database():
+    updater = VersionUpdater()
+    return updater.initialize_database()
+
+def update_versions(browser_type="all"):
+    """
+    Update browser version data for specified browser type(s).
+    This function updates version information for various browsers by delegating
+    to the appropriate update method of the VersionUpdater class.
+    Args:
+        browser_type (str, optional): The type of browser to update. Defaults to "all".
+            Supported values:
+            - "all": Updates all supported browsers
+            - "chrome": Updates Chrome browser versions
+            - "firefox": Updates Firefox browser versions
+            - "opera": Updates Opera browser versions
+            - "android": Updates Android browser versions
+            - "mac": Updates Mac browser versions
+    Returns:
+        tuple or dict: 
+            - If browser_type is "all": Returns the result from update_all()
+            - If browser_type is a specific browser: Returns a tuple of (added, updated)
+              where added is the number of newly added versions and updated is the
+              number of updated versions
+    Raises:
+        ValueError: If an unsupported browser type is provided.
+    Examples:
+        >>> update_versions()  # Updates all browsers
+        >>> update_versions("chrome")  # Updates Chrome only
+        Chrome: +5 added, 3 updated
+    """
+
+    updater = VersionUpdater()
+    
+    if browser_type.lower() == "all":
+        return updater.update_all()
+    elif browser_type.lower() == "chrome":
+        added, updated = updater.update_chrome()
+        print(f"Chrome: +{added} added, {updated} updated")
+        return added, updated
+    elif browser_type.lower() == "firefox":
+        added, updated = updater.update_firefox()
+        print(f"Firefox: +{added} added, {updated} updated")
+        return added, updated
+    elif browser_type.lower() == "opera":
+        added, updated = updater.update_opera()
+        print(f"Opera: +{added} added, {updated} updated")
+        return added, updated
+    elif browser_type.lower() == "android":
+        added, updated = updater.update_android()
+        print(f"Android: +{added} added, {updated} updated")
+        return added, updated
+    elif browser_type.lower() == "mac":
+        added, updated = updater.update_mac()
+        print(f"Mac: +{added} added, {updated} updated")
+        return added, updated
+        
+    else:
+        raise ValueError(f"Unsupported browser type: {browser_type}")
+
+def generate_user_agent(browser="Chrome"):
+    """
+    Generate a random user agent string for the specified browser.
+    
+    Args:
+        browser (str, optional): The browser type to generate a user agent for.
+            Defaults to "Chrome". Common options include "Chrome", "Firefox",
+            "Safari", "Edge", etc.
+    
+    Returns:
+        str: A randomly generated user agent string for the specified browser.
+    
+    Example:
+        >>> ua = generate_user_agent("Firefox")
+        >>> print(ua)
+        Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0
+    """
+    generator = UserAgentGenerator()
+    return generator.create_useragent(browser)
+
+def generate_multiple(count=10):
+    """
+    Generate multiple random user agent strings.
+    
+    Args:
+        count (int, optional): The number of user agent strings to generate. Defaults to 10.
+    
+    Returns:
+        list: A list of randomly generated user agent strings.
+    
+    Example:
+        >>> user_agents = generate_multiple(5)
+        >>> len(user_agents)
+        5
+    """
+    generator = UserAgentGenerator()
+    return generator.get_list(count)
+
+try:
+    from .cli import main as cli_main
+    __all__.append('cli_main')
+except ImportError:
+    pass
+
+try:
+    import os
+    from pathlib import Path
+    
+    db_dir = Path(__file__).parent / "data"
+    db_path = db_dir / "useragent.db"
+    
+    if not db_path.exists():
+        print("Warning: Database not found.")
+        print("Run the 'useragent-gen --init' command before first use.")
+        
+except Exception:
+    pass

uaforge/cli.py

@@ -0,0 +1,105 @@
+import argparse
+import sys
+from . import generate_user_agent, generate_multiple, update_versions, init_database, __version__
+from .core.user_agent import UserAgentGenerator
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="UAForge - UserAgent Generator CLI\n\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --count 5 --browser Chrome
+  %(prog)s --count 10 --output useragents.txt
+  %(prog)s --update all
+  %(prog)s --init
+        """
+    )
+    
+    parser.add_argument("--count", "-c", type=int, default=1, 
+                       help="Number of user agents to be created (default: 1)")
+    
+    parser.add_argument("--browser", "-b", 
+                       choices=["Chrome", "Firefox", "Opera", "random"], 
+                       default="random", 
+                       help="Browser type (default: random)")
+    
+    parser.add_argument("--output", "-o", 
+                       help="Output file (optional)")
+    
+    parser.add_argument("--update", "-u", 
+                       choices=["all", "chrome", "firefox", "opera", "android", "windows", "linux", "mac"],
+                       help="Update version information.")
+    
+    parser.add_argument("--init", action="store_true",
+                       help="Populate the database with initial data.")
+    
+    parser.add_argument("--version", "-v", action="store_true",
+                       help="Show version information")
+    
+    args = parser.parse_args()
+    
+    if args.version:
+        print(f"UAForge v{__version__}")
+        return
+    
+    if args.init:
+        print("Initializing the database...")
+        if init_database():
+            print("Database successfully started!")
+        else:
+            print("Database initialization failed!")
+        return
+    
+    if args.update:
+        if args.update not in "all":
+            print(f"{args.update} versions are being updated...")
+        try:
+            update_versions(args.update)
+            print("Update complete!")
+        except Exception as e:
+            print(f"Error: {e}")
+        return
+    
+    if args.browser == "random":
+        import random
+        browser = random.choice(["Chrome", "Firefox", "Opera"])
+    else:
+        browser = args.browser
+    
+    try:
+        generator = UserAgentGenerator()
+        
+        if args.count == 1:
+            user_agent = generator.create_useragent(browser)
+            print(user_agent)
+            
+            if args.output:
+                with open(args.output, "w", encoding="utf-8") as f:
+                    f.write(user_agent + "\n")
+        else:
+            user_agents = generator.get_list(args.count)
+            
+            for i, ua in enumerate(user_agents, 1):
+                print(f"{i:3}. {ua}")
+            
+            if args.output:
+                import os
+                from .utils import save_useragents_to_file
+                
+                if os.path.exists(args.output):
+                    overwrite = input(f"The {args.output} file already exists. Should it be overwritten? (yes/no)")
+                    if overwrite.lower() != 'e':
+                        print("The transaction has been cancelled.")
+                        return
+                
+                save_useragents_to_file(user_agents, args.output)
+                print(f"\n{args.count} user agent saved to file '{args.output}'.")
+    
+    except Exception as e:
+        print(f"Error: {e}")
+        print("\nTip: Run the '--init' or '--update all' command for the first use.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

uaforge/core/__init__.py

@@ -0,0 +1,6 @@
+from ..core.user_agent import UserAgentGenerator
+from ..core.database import Database
+from ..core.version_fetcher import VersionFetcher
+
+__version__ = "1.0.0"
+__all__ = ['UserAgentGenerator', 'Database', 'VersionFetcher', 'generate_user_agent', 'generate_multiple']

uaforge/core/database.py

@@ -0,0 +1,413 @@
+import sqlite3
+import os
+from typing import List, Tuple, Dict, Any
+from datetime import datetime
+from pathlib import Path
+
+class Database:
+    
+    def __init__(self, db_path: str = None):
+        if db_path is None:
+            current_dir = Path(__file__).parent
+            db_dir = current_dir.parent / "data"
+            db_dir.mkdir(exist_ok=True)
+            db_path = str(db_dir / "useragent.db")
+        
+        self.db_path = db_path
+        self._init_database()
+    
+    def _init_database(self):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS chrome_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS firefox_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS opera_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS android_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS windows_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS macos_versions (
+                version TEXT PRIMARY KEY,
+                release_date TEXT,
+                last_updated TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS platforms (
+                platform TEXT,
+                system_info TEXT,
+                PRIMARY KEY (platform, system_info)
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS version_types (
+                platform TEXT,
+                version_type TEXT,
+                PRIMARY KEY (platform, version_type)
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def get_connection(self):
+        return sqlite3.connect(self.db_path)
+    
+    def get_device_version(self) -> Dict[str, List[str]]:
+        platforms = {}
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT platform, system_info FROM platforms")
+            rows = cursor.fetchall()
+            
+            for platform, system_info in rows:
+                if platform not in platforms:
+                    platforms[platform] = []
+                platforms[platform].append(system_info)
+        finally:
+            conn.close()
+        
+        return platforms
+    
+    def get_version_type_connect(self) -> Dict[str, List[str]]:
+        version_types = {}
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT platform, version_type FROM version_types")
+            rows = cursor.fetchall()
+            
+            for platform, version_type in rows:
+                if platform not in version_types:
+                    version_types[platform] = []
+                version_types[platform].append(version_type)
+        finally:
+            conn.close()
+        
+        return version_types
+    
+    def get_chrome_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM chrome_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def get_firefox_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM firefox_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def get_opera_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM opera_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def get_android_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM android_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def get_windows_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM windows_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def get_macos_vers(self) -> Tuple[List[str], List[Tuple]]:
+        versions = []
+        version_data = []
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("SELECT version, release_date, last_updated FROM macos_versions")
+            rows = cursor.fetchall()
+            
+            for version, release_date, last_updated in rows:
+                versions.append(version)
+                version_data.append((version, release_date, last_updated))
+        finally:
+            conn.close()
+        
+        return (versions, version_data)
+    
+    def add_chrome_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO chrome_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE chrome_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def add_firefox_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO firefox_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE firefox_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+ 
+    def add_opera_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO opera_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE opera_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def add_android_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO android_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE android_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def add_windows_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO windows_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE windows_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+ 
+    def add_macos_versions(self, dt_add: list, dt_update: list = None):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            for version, release_date, last_updated in dt_add:
+                cursor.execute('''
+                    INSERT OR REPLACE INTO macos_versions 
+                    (version, release_date, last_updated) 
+                    VALUES (?, ?, ?)
+                ''', (version, release_date, last_updated))
+            
+            if dt_update:
+                for version, release_date, last_updated in dt_update:
+                    cursor.execute('''
+                        UPDATE macos_versions 
+                        SET release_date = ?, last_updated = ?
+                        WHERE version = ?
+                    ''', (release_date, last_updated, version))
+            
+            conn.commit()
+        finally:
+            conn.close()
+               
+    def add_platforms(self, platforms_data: list):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("DELETE FROM platforms")
+            
+            for platform, system_info in platforms_data:
+                cursor.execute(
+                    "INSERT OR REPLACE INTO platforms (platform, system_info) VALUES (?, ?)",
+                    (platform, system_info)
+                )
+            
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def add_version_types(self, version_types_data: list):
+        conn = self.get_connection()
+        cursor = conn.cursor()
+        
+        try:
+            cursor.execute("DELETE FROM version_types")
+            
+            for platform, version_type in version_types_data:
+                cursor.execute(
+                    "INSERT OR REPLACE INTO version_types (platform, version_type) VALUES (?, ?)",
+                    (platform, version_type)
+                )
+            
+            conn.commit()
+        finally:
+            conn.close()