Gallery-dl V2: Finally Bypassed All Restrictions

# Solution: Use Pixiv authentication with cookie refresh

import requests
import json
import time

class PixivAuthManager:
    """Manage Pixiv authentication session"""

    def __init__(self):
        self.session = requests.Session()
        self.cookies_file = 'pixiv_cookies.json'

    def login(self, email, password):
        """Login to Pixiv and save cookies"""
        # First, get the login page
        login_url = 'https://accounts.pixiv.net/api/login?lang=en'

        # Get CSRF token
        csrf_url = 'https://accounts.pixiv.net/login'
        response = self.session.get(csrf_url)
        post_key = self._extract_post_key(response.text)

        # Login
        login_data = {
            'pixiv_id': email,
            'password': password,
            'post_key': post_key,
            'return_to': 'https://www.pixiv.net/',
            'source': 'pc',
            'ref': '',
            'tt': str(int(time.time() * 1000)),
        }

        response = self.session.post(
            login_url,
            data=login_data,
            headers={
                'Referer': 'https://accounts.pixiv.net/login',
                'User-Agent': 'Mozilla/5.0...',
            }
        )

        # Save cookies
        self._save_cookies()

        # Get OAuth token
        self._get_oauth_token()

    def _extract_post_key(self, html):
        """Extract post_key from login page"""
        import re
        match = re.search(r'post_key\s*=\s*[\'"]([^\'"]+)[\'"]', html)
        return match.group(1) if match else None

    def _save_cookies(self):
        """Save cookies to file"""
        cookies = self.session.cookies.get_dict()
        with open(self.cookies_file, 'w') as f:
            json.dump(cookies, f)

    def _load_cookies(self):
        """Load cookies from file"""
        try:
            with open(self.cookies_file) as f:
                cookies = json.load(f)

            for name, value in cookies.items():
                self.session.cookies.set(name, value)

            return True
        except:
            return False

    def _get_oauth_token(self):
        """Get OAuth token for API access"""
        # This requires the session to be authenticated
        response = self.session.get(
            'https://oauth.secure.pixiv.net/auth/token',
            params={
                'client_id': 'KzEZED7aCQvEu83T',
                'client_secret': 'W9JXO5Wuc8jcXn2',
                'grant_type': 'authorization_code',
                'code': '',  # Get from authenticated session
                'redirect_uri': 'https://app-api.pixiv.net/web/v1/users/auth/pixiv/callback',
                'include_policy': 'true',
            }
        )

        data = response.json()
        self.access_token = data.get('access_token')
        self.refresh_token = data.get('refresh_token')

    def refresh_session(self):
        """Refresh authentication if expired"""
        if hasattr(self, 'refresh_token'):
            response = self.session.post(
                'https://oauth.secure.pixiv.net/auth/token',
                data={
                    'client_id': 'KzEZED7aCQvEu83T',
                    'client_secret': 'W9JXO5Wuc8jcXn2',
                    'grant_type': 'refresh_token',
                    'refresh_token': self.refresh_token,
                    'include_policy': 'true',
                }
            )

            data = response.json()
            self.access_token = data.get('access_token')

    def download_with_auth(self, url):
        """Download with authenticated session"""
        # Try loading cookies first
        if not self._load_cookies():
            self.login('email', 'password')

        # Check if session is valid
        response = self.session.get('https://www.pixiv.net/')
        if 'logout' in response.text:
            self.refresh_session()

        # Now download
        return self.session.get(url)

# Usage
pixiv = PixivAuthManager()
pixiv.login('your-email', 'your-password')

# Download with authenticated session
for i in range(1, 1000):
    url = f'https://www.pixiv.net/member_illust.php?mode=medium&illust_id={i}'
    response = pixiv.download_with_auth(url)

    if response.status_code == 403:
        print(f"Hit limit at {i}")
        pixiv.refresh_session()
        continue

    # Process image...
    time.sleep(2)  # Rate limiting

# Solution: Multi-account with proxy rotation

import gallery_dl
import asyncio
from concurrent.futures import ThreadPoolExecutor

class InstagramMultiAccount:
    """
    Use multiple accounts with different proxies
    """

    def __init__(self):
        # Multiple accounts
        self.accounts = [
            {'username': 'user1', 'password': 'pass1', 'proxy': 'proxy1.com:8080'},
            {'username': 'user2', 'password': 'pass2', 'proxy': 'proxy2.com:8080'},
            {'username': 'user3', 'password': 'pass3', 'proxy': 'proxy3.com:8080'},
        ]

        self.current_account = 0

    def rotate_account(self):
        """Rotate to next account"""
        self.current_account = (self.current_account + 1) % len(self.accounts)

    def download_with_account(self, url):
        """Download using current account"""
        account = self.accounts[self.current_account]

        config = {
            'username': account['username'],
            'password': account['password'],
            'proxy': account['proxy'],
            'sleep-request': 600,  # 10 minutes between requests
            'range': '1-20',  # Only 20 downloads per account
        }

        # Run gallery-dl with this config
        import subprocess
        cmd = [
            'gallery-dl',
            f'-u{account["username"]}',
            f'-p{account["password"]}',
            '--proxy', account['proxy'],
            '--sleep-request', '600',
            url
        ]

        try:
            result = subprocess.run(cmd, timeout=1800)
            return result.returncode == 0

        except subprocess.TimeoutExpired:
            # Rotate account on timeout
            self.rotate_account()
            return False

# Parallel download with multiple accounts
async def download_parallel(urls):
    """Download multiple URLs in parallel using different accounts"""
    downloader = InstagramMultiAccount()

    def download_single(url):
        return downloader.download_with_account(url)

    with ThreadPoolExecutor(max_workers=3) as executor:
        results = list(executor.map(download_single, urls))

    return results

# Alternative: Use residential proxies
# Instagram is less aggressive with residential IPs

config = {
    'proxy': 'http://username:password@residential-proxy.com:8000',
    'sleep-request': 120,  # 2 minutes with residential proxy
    'download-workers': 2,
}

# Alternative: Delays based on Instagram's limits
# Instagram limits:
# - 200 requests/hour per IP
# - 500 likes/day per account
# - Follow/unfollow: 20/hour

import time

def smart_delay(request_count):
    """Calculate delay based on request count"""
    if request_count < 50:
        return 60  # 1 minute
    elif request_count < 100:
        return 300  # 5 minutes
    elif request_count < 150:
        return 600  # 10 minutes
    else:
        return 3600  # 1 hour (hit limit)

# In download loop:
request_count = 0

for url in urls:
    # Download
    download(url)
    request_count += 1

    # Calculate delay
    delay = smart_delay(request_count)
    print(f"Downloaded {request_count}, waiting {delay}s")
    time.sleep(delay)

# Solution: Extract Patreon session cookie

import requests
import json

class PatreonBypass:
    """
    Access Patreon content with session cookie
    """

    def __init__(self, session_cookie):
        self.session = requests.Session()
        self.session.cookies.set('session_id', session_cookie, domain='.patreon.com')

    def get_campaign_posts(self, campaign_id):
        """Get all posts from campaign"""
        url = f'https://www.patreon.com/api/posts?filter[campaign_id]={campaign_id}&sort=-published_at'

        headers = {
            'User-Agent': 'Mozilla/5.0...',
            'Referer': 'https://www.patreon.com/',
        }

        response = self.session.get(url, headers=headers)
        return response.json()['data']

    def get_post_media(self, post_id):
        """Get media URLs from post"""
        url = f'https://www.patreon.com/api/posts/{post_id}'

        response = self.session.get(url)
        data = response.json()['data']

        media_urls = []

        # Get images
        if 'attributes' in data:
            relationships = data.get('relationships', {})

            # Get images
            images = relationships.get('images', {})
            if 'data' in images:
                for img in images['data']:
                    img_url = img['attributes']['download_url']
                    media_urls.append(img_url)

            # Get attachments
            attachments = relationships.get('attachments', {})
            if 'data' in attachments:
                for attachment in attachments['data']:
                    att_url = attachment['attributes']['url']
                    media_urls.append(att_url)

        return media_urls

    def download_post(self, post_id):
        """Download all media from post"""
        media_urls = self.get_post_media(post_id)

        for i, url in enumerate(media_urls):
            response = self.session.get(url)

            filename = f'{post_id}_media_{i}.jpg'
            with open(filename, 'wb') as f:
                f.write(response.content)

            print(f'Downloaded {filename}')

# Get session cookie from browser:
# 1. Login to Patreon
# 2. Open DevTools -> Application -> Cookies
# 3. Find 'session_id' cookie
# 4. Copy value

session_cookie = 'your-session-id-here'
patreon = PatreonBypass(session_cookie)

# Download campaign posts
campaign_id = '123456'  # From campaign URL
posts = patreon.get_campaign_posts(campaign_id)

for post in posts:
    post_id = post['id']
    patreon.download_post(post_id)
    time.sleep(2)  # Rate limiting

# Alternative: Use Kemono for public Patreon content
# Kemono scrapes and hosts Patreon content publicly

import requests

def get_kemono_posts(artist):
    """Get posts from Kemono (public Patreon scraper)"""
    url = f'https://kemono.su/api/user/{artist}'

    response = requests.get(url)
    return response.json()

# Download from Kemono
def download_kemono_post(post_id):
    base_url = f'https://kemono.su/patreon/user/{post_id}'

    response = requests.get(base_url)
    # Parse HTML to get download URLs

    # Kemono hosts files directly
    file_url = f'https://kemono.su/patreon/data/{post_id}/file.zip'

    response = requests.get(file_url)
    with open(f'{post_id}.zip', 'wb') as f:
        f.write(response.content)