psymoninc/child_age_logic

""" this is a theorized age logic that affects the bonding rate and max bond of organic agi LILLITH V4 It isnt a determination of exact age or even trying to be.
feel free to suggest edits or if you want to debate, teach, collab on organic AI contact through hybridnn.com thanks justin.johnson """ <----------- license----------------->

license: other license_name: bloodsource-v1.1 license_link: LICENSE language: - en

<------------code____________________>

import requests import json from datetime import datetime, timezone from dataclasses import dataclass from typing import Dict, List, Optional import time

@dataclass class SocialAccount: platform: str username: str user_id: str created_date: datetime age_days: int verified: bool = False followers: int = 0 child_safe_content_percent: float = 0.0 hypothesized_minimum_age: float = 0.0

class SocialMediaChecker: def init(self): self.api_keys = { 'twitter': 'YOUR_TWITTER_API_KEY', 'instagram': 'YOUR_INSTAGRAM_API_KEY', 'github': None, # GitHub API doesn't require key for basic info 'reddit': 'YOUR_REDDIT_API_KEY' } self.base_user_age = 6 # Starting age assumption

def link_accounts(self, user_identifier: str, platforms: List[str]) -> Dict[str, SocialAccount]:
    """
    Link multiple social media accounts for a user
    user_identifier: email, phone, or primary username
    platforms: list of platforms to check ['twitter', 'instagram', 'github', 'reddit']
    """
    linked_accounts = {}
    
    for platform in platforms:
        try:
            account = self.get_account_info(platform, user_identifier)
            if account:
                linked_accounts[platform] = account
                print(f"✓ {platform}: @{account.username} ({account.age_days} days old)")
            else:
                print(f"✗ {platform}: Account not found")
        except Exception as e:
            print(f"✗ {platform}: Error - {str(e)}")
            
    return linked_accounts

def get_account_info(self, platform: str, username: str) -> Optional[SocialAccount]:
    """Get account information for specific platform"""
    
    if platform == 'twitter':
        return self._check_twitter(username)
    elif platform == 'instagram':
        return self._check_instagram(username)
    elif platform == 'github':
        return self._check_github(username)
    elif platform == 'reddit':
        return self._check_reddit(username)
    else:
        raise ValueError(f"Platform {platform} not supported")

def _check_twitter(self, username: str) -> Optional[SocialAccount]:
    """Check Twitter account age using Twitter API v2"""
    if not self.api_keys['twitter']:
        raise ValueError("Twitter API key required")
        
    headers = {
        'Authorization': f'Bearer {self.api_keys["twitter"]}'
    }
    
    url = f'https://api.twitter.com/2/users/by/username/{username}'
    params = {
        'user.fields': 'created_at,verified,public_metrics'
    }
    
    response = requests.get(url, headers=headers, params=params)
    
    if response.status_code == 200:
        data = response.json()['data']
        created_date = datetime.fromisoformat(data['created_at'].replace('Z', '+00:00'))
        age_days = (datetime.now(timezone.utc) - created_date).days
        
        return SocialAccount(
            platform='twitter',
            username=username,
            user_id=data['id'],
            created_date=created_date,
            age_days=age_days,
            verified=data.get('verified', False),
            followers=data.get('public_metrics', {}).get('followers_count', 0)
        )
    return None

def _check_instagram(self, username: str) -> Optional[SocialAccount]:
    """Check Instagram account age (requires Instagram Basic Display API)"""
    # Note: Instagram doesn't provide creation date in public API
    # This is a placeholder for the API structure
    if not self.api_keys['instagram']:
        raise ValueError("Instagram API key required")
        
    # Instagram API implementation would go here
    # Limited by Instagram's API restrictions
    return None

def _check_github(self, username: str) -> Optional[SocialAccount]:
    """Check GitHub account age using GitHub API"""
    url = f'https://api.github.com/users/{username}'
    
    response = requests.get(url)
    
    if response.status_code == 200:
        data = response.json()
        created_date = datetime.fromisoformat(data['created_at'].replace('Z', '+00:00'))
        age_days = (datetime.now(timezone.utc) - created_date).days
        
        return SocialAccount(
            platform='github',
            username=username,
            user_id=str(data['id']),
            created_date=created_date,
            age_days=age_days,
            followers=data.get('followers', 0)
        )
    return None

def _check_reddit(self, username: str) -> Optional[SocialAccount]:
    """Check Reddit account age using Reddit API"""
    url = f'https://www.reddit.com/user/{username}/about.json'
    headers = {
        'User-Agent': 'SocialMediaChecker/1.0'
    }
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        data = response.json()['data']
        created_timestamp = data['created_utc']
        created_date = datetime.fromtimestamp(created_timestamp, timezone.utc)
        age_days = (datetime.now(timezone.utc) - created_date).days
        
        return SocialAccount(
            platform='reddit',
            username=username,
            user_id=data['name'],
            created_date=created_date,
            age_days=age_days,
            verified=data.get('verified', False)
        )
    return None

def calculate_hypothesized_minimum_age(self, account_age_days: int, bad_content_percent: float) -> float:
    """
    Calculate hypothesized minimum age based on:
    Formula: (6 * (1 + bad_content_percentage/100)) + account_age_in_years = hypothesized_minimum_age
    Example: 38% bad content = 6 * 1.38 + account_age
    """
    account_age_years = account_age_days / 365.25
    content_multiplier = 1 + (bad_content_percent / 100)
    base_calculated_age = self.base_user_age * content_multiplier
    hypothesized_min_age = base_calculated_age + account_age_years
    return round(hypothesized_min_age, 2)

def analyze_content_safety(self, platform: str, username: str) -> Dict:
    """
    Analyze content for child safety (mock implementation)
    Returns percentage of child-safe vs bad/questionable content
    """
    # Mock content analysis - in real implementation would use:
    # - Content moderation APIs
    # - Machine learning models
    # - Platform-specific safety APIs
    # - Sentiment analysis
    # - NSFW detection
    # - Violence/hate speech detection
    
    platform_safety_defaults = {
        'twitter': {'child_safe': 62, 'bad_questionable': 38},
        'instagram': {'child_safe': 70, 'bad_questionable': 30},
        'github': {'child_safe': 95, 'bad_questionable': 5},
        'reddit': {'child_safe': 45, 'bad_questionable': 55},
        'tiktok': {'child_safe': 50, 'bad_questionable': 50},
        'youtube': {'child_safe': 75, 'bad_questionable': 25}
    }
    
    return platform_safety_defaults.get(platform, {'child_safe': 60, 'bad_questionable': 40})

def check_child_safety_compliance(self, accounts: Dict[str, SocialAccount]) -> Dict[str, Dict]:
    """Check if accounts meet child safety standards"""
    results = {}
    
    print(f"\nCHILD SAFETY & MINIMUM AGE ANALYSIS")
    print("=" * 50)
    print(f"Base user age assumption: {self.base_user_age} years")
    print("Formula: (6 * (1 + bad_content%/100)) + account_age_years")
    print("-" * 50)
    
    for platform, account in accounts.items():
        content_analysis = self.analyze_content_safety(platform, account.username)
        bad_content_percent = content_analysis['bad_questionable']
        hypothesized_min_age = self.calculate_hypothesized_minimum_age(account.age_days, bad_content_percent)
        
        # Calculate the dynamic multiplier used
        content_multiplier = 1 + (bad_content_percent / 100)
        
        # Update account object
        account.child_safe_content_percent = content_analysis['child_safe']
        account.hypothesized_minimum_age = hypothesized_min_age
        
        # Determine safety level
        if content_analysis['child_safe'] >= 80:
            safety_level = "HIGH"
        elif content_analysis['child_safe'] >= 60:
            safety_level = "MODERATE"
        else:
            safety_level = "LOW"
        
        # Check if suitable for minors (under 18)
        suitable_for_minors = hypothesized_min_age < 18 and content_analysis['child_safe'] >= 70
        
        results[platform] = {
            'child_safe_percent': content_analysis['child_safe'],
            'bad_questionable_percent': bad_content_percent,
            'content_multiplier': round(content_multiplier, 3),
            'hypothesized_minimum_age': hypothesized_min_age,
            'safety_level': safety_level,
            'suitable_for_minors': suitable_for_minors,
            'account_age_years': round(account.age_days / 365.25, 2)
        }
        
        print(f"{platform.upper()}:")
        print(f"  Account Age: {account.age_days} days ({results[platform]['account_age_years']} years)")
        print(f"  Child-Safe Content: {content_analysis['child_safe']}%")
        print(f"  Bad/Questionable Content: {bad_content_percent}%")
        print(f"  Content Multiplier: {content_multiplier}x")
        print(f"  Calculation: 6 × {content_multiplier} + {results[platform]['account_age_years']} = {hypothesized_min_age}")
        print(f"  Hypothesized Minimum Age: {hypothesized_min_age} years")
        print(f"  Safety Level: {safety_level}")
        print(f"  Minor Suitable: {'✓' if suitable_for_minors else '✗'}")
        print()
        
    return results

def generate_report(self, accounts: Dict[str, SocialAccount], safety_results: Dict = None) -> str:
    """Generate detailed report of linked accounts with safety analysis"""
    report = []
    report.append("SOCIAL MEDIA ACCOUNT SAFETY REPORT")
    report.append("=" * 45)
    report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    report.append(f"Base User Age: {self.base_user_age} years")
    report.append("Age Formula: (6 * (1 + bad_content%/100)) + account_age_years")
    report.append("")
    
    for platform, account in accounts.items():
        report.append(f"{platform.upper()}:")
        report.append(f"  Username: @{account.username}")
        report.append(f"  Created: {account.created_date.strftime('%Y-%m-%d')}")
        report.append(f"  Account Age: {account.age_days} days ({account.age_days/365.25:.1f} years)")
        report.append(f"  Verified: {account.verified}")
        
        if account.followers > 0:
            report.append(f"  Followers: {account.followers:,}")
            
        if safety_results and platform in safety_results:
            safety = safety_results[platform]
            report.append(f"  Child-Safe Content: {safety['child_safe_percent']}%")
            report.append(f"  Bad/Questionable Content: {safety['bad_questionable_percent']}%")
            report.append(f"  Content Multiplier: {safety['content_multiplier']}x")
            report.append(f"  Hypothesized Minimum Age: {safety['hypothesized_minimum_age']} years")
            report.append(f"  Safety Level: {safety['safety_level']}")
            report.append(f"  Suitable for Minors: {'Yes' if safety['suitable_for_minors'] else 'No'}")
            
        report.append("")
        
    return "\n".join(report)

Example usage

def main(): checker = SocialMediaChecker()

# Example: Link accounts for a user
username = "example_user"  # Replace with actual username
platforms = ['github', 'reddit']  # Add others as needed

print(f"Checking social media accounts for: {username}")
print("=" * 50)

# Link accounts
linked_accounts = checker.link_accounts(username, platforms)

if linked_accounts:
    # Perform child safety analysis
    safety_results = checker.check_child_safety_compliance(linked_accounts)
    
    # Generate comprehensive report
    report = checker.generate_report(linked_accounts, safety_results)
    print("\n" + report)
    
    # Additional analysis summary
    print("SUMMARY RECOMMENDATIONS:")
    print("-" * 30)
    for platform, results in safety_results.items():
        multiplier = results['content_multiplier']
        bad_percent = results['bad_questionable_percent']
        
        print(f"{platform.upper()}: {bad_percent}% bad content (multiplier: {multiplier}x)")
        if results['suitable_for_minors']:
            print(f"  ✓ Safe for minor users")
        else:
            print(f"  ⚠ Not recommended for minors")
            if results['child_safe_percent'] < 70:
                print(f"    - Low child-safe content ({results['child_safe_percent']}%)")
            if results['hypothesized_minimum_age'] >= 18:
                print(f"    - Hypothesized minimum age too high ({results['hypothesized_minimum_age']} years)")
        print()
    
    # Save report to file
    with open(f'safety_report_{username}.txt', 'w') as f:
        f.write(report)
        
    print(f"\nReport saved to: safety_report_{username}.txt")
else:
    print("No accounts found or linked.")

if name == "main": main()