eses 1.0.3__tar.gz → 1.0.5__tar.gz

{eses-1.0.3 → eses-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eses
-Version: 1.0.3
+Version: 1.0.5
 Summary: A library for sending donation requests with proxy rotation
 Author-email: Your Name <your@email.com>
 Project-URL: Homepage, https://github.com/yourusername/eses

eses-1.0.5/eses/__init__.py

@@ -0,0 +1,136 @@
+import requests
+import time
+import threading
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+
+# API Configuration
+api_url = "http://52.24.104.170:8086/RestSimulator"
+proxies: List[str] = []
+proxy_lock = threading.Lock()
+active_threads: List[threading.Thread] = []
+
+# Debug Utilities
+def _print_debug(msg: str) -> None:
+    """Print debug messages with timestamps"""
+    timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+    print(f"[{timestamp}] {msg}")
+
+# Core Functions
+def addproxy(proxy: str) -> None:
+    """Add a proxy to the rotation pool"""
+    if not proxy.startswith(('http://', 'https://')):
+        proxy = f"http://{proxy}"
+    
+    with proxy_lock:
+        if proxy not in proxies:
+            proxies.append(proxy)
+            _print_debug(f"Proxy added: {proxy}")
+        else:
+            _print_debug(f"Proxy already exists: {proxy}")
+
+def clear_proxies() -> None:
+    """Clear all registered proxies"""
+    with proxy_lock:
+        proxies.clear()
+    _print_debug("All proxies cleared")
+
+def donate(
+    company_name: str,
+    country: str,
+    war_id: str,
+    donation_sum: str = "100000000000",
+    proxy: Optional[str] = None
+) -> Optional[Dict[str, Any]]:
+    """
+    Send a single donation request
+    Returns: JSON response if successful, None otherwise
+    """
+    params = {
+        "Operation": "postDonation",
+        "available_patriotism": "0",
+        "company_id": "4456964",
+        "company_name": company_name,
+        "country": country,
+        "donation_sum": donation_sum,
+        "donation_type": "0",
+        "sender_company_id": "4456964",
+        "user_id": "3CE57CF11AFA43A1ABB7DB10431C2234",
+        "version_code": "22",
+        "war_id": war_id
+    }
+
+    proxy_display = proxy or "DIRECT"
+    _print_debug(f"Starting donation: {company_name} via {proxy_display}")
+
+    try:
+        start_time = time.time()
+        response = requests.post(
+            api_url,
+            params=params,
+            headers={"Content-Length": "0"},
+            proxies={"http": proxy, "https": proxy} if proxy else None,
+            timeout=10
+        )
+        elapsed_ms = int((time.time() - start_time) * 1000)
+        
+        _print_debug(f"Success ({response.status_code}) in {elapsed_ms}ms")
+        _print_debug(f"Response: {response.text[:200]}")
+        return response.json()
+    except Exception as e:
+        _print_debug(f"Failed via {proxy_display}: {str(e)}")
+        return None
+
+def donatewithproxy(
+    company_name: str,
+    country: str,
+    war_id: str,
+    times: int = 1,
+    delay: int = 0
+) -> None:
+    """
+    Start automated donations with proxy rotation
+    Args:
+        times: Requests per proxy per cycle
+        delay: Seconds between full cycles
+    """
+    def _worker():
+        cycle = 0
+        while True:
+            cycle += 1
+            _print_debug(f"=== START CYCLE {cycle} ===")
+            
+            # Get current proxy list (thread-safe)
+            with proxy_lock:
+                current_proxies = proxies.copy() or [None]  # None means direct connection
+            
+            # Process each proxy
+            for proxy in current_proxies:
+                for attempt in range(1, times + 1):
+                    _print_debug(f"Attempt {attempt}/{times} via {proxy or 'DIRECT'}")
+                    donate(company_name, country, war_id, proxy=proxy)
+            
+            # Cycle complete
+            _print_debug(f"Cycle {cycle} complete. Waiting {delay}s...")
+            time.sleep(delay)
+
+    thread = threading.Thread(target=_worker, daemon=True)
+    thread.start()
+    active_threads.append(thread)
+    _print_debug(f"Started donation thread (ID: {thread.ident})")
+
+def stop_all_donations() -> None:
+    """Gracefully stop all active donation threads"""
+    for thread in active_threads:
+        thread.join(timeout=1)
+    active_threads.clear()
+    _print_debug("All donation threads stopped")
+
+# Make functions available at package level
+__all__ = [
+    'addproxy',
+    'clear_proxies',
+    'donate',
+    'donatewithproxy',
+    'stop_all_donations'
+]

eses-1.0.5/eses/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.5

{eses-1.0.3 → eses-1.0.5}/eses.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eses
-Version: 1.0.3
+Version: 1.0.5
 Summary: A library for sending donation requests with proxy rotation
 Author-email: Your Name <your@email.com>
 Project-URL: Homepage, https://github.com/yourusername/eses

{eses-1.0.3 → eses-1.0.5}/eses.egg-info/SOURCES.txt

@@ -2,11 +2,9 @@ LICENSE
 README.md
 pyproject.toml
 eses/__init__.py
-eses/eses.py
 eses/version.py
 eses.egg-info/PKG-INFO
 eses.egg-info/SOURCES.txt
 eses.egg-info/dependency_links.txt
 eses.egg-info/requires.txt
-eses.egg-info/top_level.txt
-tests/test_basic.py
+eses.egg-info/top_level.txt

{eses-1.0.3 → eses-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eses"
-version = "1.0.3"  # Must match version.py
+version = "1.0.5"  # Must match version.py
 authors = [
     {name = "Your Name", email = "your@email.com"},
 ]

eses-1.0.3/eses/__init__.py

@@ -1,28 +0,0 @@
-from .eses import ESES
-
-# Create module-level instance
-eses = ESES()
-
-# Expose main methods at package level
-donate = eses.donate
-add_proxy = eses.add_proxy
-rotateproxy = eses.rotateproxy
-stop_rotation = eses.stop_rotation
-get_proxy_list = eses.get_proxy_list
-set_default_param = eses.set_default_param
-set_default_header = eses.set_default_header
-clear_proxies = eses.clear_proxies
-
-# Explicit exports
-__all__ = [
-    'ESES',
-    'eses',
-    'donate',
-    'add_proxy',
-    'rotateproxy',
-    'stop_rotation',
-    'get_proxy_list',
-    'set_default_param',
-    'set_default_header',
-    'clear_proxies'
-]

eses-1.0.3/eses/eses.py

@@ -1,201 +0,0 @@
-import requests
-import time
-from itertools import cycle
-import threading
-
-class ESES:
-    def __init__(self):
-        # Default configuration
-        self.api_url = "http://52.24.104.170:8086/RestSimulator"
-        self.default_params = {
-            "Operation": "postDonation",
-            "available_patriotism": "0",
-            "company_id": "4456964",
-            "donation_sum": "100000000000",
-            "donation_type": "0",
-            "sender_company_id": "4456964",
-            "user_id": "3CE57CF11AFA43A1ABB7DB10431C2234",
-            "version_code": "22"
-        }
-
-        self.default_headers = {
-            "Host": "52.24.104.170:8086",
-            "Connection": "Keep-Alive",
-            "User-Agent": "android-async-http",
-            "Accept-Encoding": "gzip",
-            "Content-Length": "0"
-        }
-
-        # Proxy management
-        self.proxies = []
-        self.proxy_cycle = None
-        self.running = False
-        self.rotation_thread = None
-        self.current_donation_params = {}
-
-    def donate(self, company_name, country, war_id):
-        """
-        Send a donation request with required parameters
-        
-        Args:
-            company_name (str): Name of the company (required)
-            country (str): Country name (required)
-            war_id (str): War ID (required)
-            
-        Returns:
-            dict: Dictionary containing status, status_code, and response/error
-        """
-        if not all([company_name, country, war_id]):
-            raise ValueError("company_name, country, and war_id are all required parameters")
-
-        # Store the current donation parameters
-        self.current_donation_params = {
-            "company_name": company_name,
-            "country": country,
-            "war_id": war_id
-        }
-
-        params = self.default_params.copy()
-        params.update(self.current_donation_params)
-        
-        try:
-            response = requests.get(
-                self.api_url,
-                params=params,
-                headers=self.default_headers,
-                timeout=10
-            )
-            return {
-                "status": "success",
-                "status_code": response.status_code,
-                "response": response.text
-            }
-        except Exception as e:
-            return {
-                "status": "error",
-                "error": str(e)
-            }
-
-    def add_proxy(self, proxy):
-        """
-        Add a proxy to the proxy list (format: ip:port)
-        
-        Args:
-            proxy (str): Proxy address in format 'ip:port'
-        """
-        # Validate proxy format
-        if ":" not in proxy:
-            raise ValueError("Proxy must be in format ip:port")
-        
-        # Convert to http://ip:port format
-        formatted_proxy = f"http://{proxy}"
-        
-        if formatted_proxy not in self.proxies:
-            self.proxies.append(formatted_proxy)
-            self.proxy_cycle = cycle(self.proxies)
-            return f"Proxy added: {proxy}"
-        return f"Proxy already exists: {proxy}"
-
-    def clear_proxies(self):
-        """Clear all proxies from the proxy list"""
-        self.proxies = []
-        self.proxy_cycle = None
-        return "All proxies cleared"
-
-    def rotateproxy(self, requests_per_proxy=None, delay_after_rotation=None):
-        """
-        Rotate through proxies making requests using current donation parameters
-        
-        Args:
-            requests_per_proxy (int): Number of requests to make per proxy (required)
-            delay_after_rotation (int): Seconds to wait after using all proxies (required)
-            
-        Returns:
-            threading.Thread: The rotation thread object
-        """
-        # Validate required parameters
-        if requests_per_proxy is None:
-            raise ValueError("requests_per_proxy is required")
-        if delay_after_rotation is None:
-            raise ValueError("delay_after_rotation is required")
-            
-        if not self.current_donation_params:
-            raise ValueError("No donation parameters set. Call donate() first")
-            
-        if not self.proxies:
-            raise ValueError("No proxies available. Add proxies using add_proxy()")
-        
-        if self.proxy_cycle is None:
-            self.proxy_cycle = cycle(self.proxies)
-        
-        self.running = True
-        
-        def rotation_worker():
-            while self.running:
-                for proxy in self.proxies:
-                    if not self.running:
-                        break
-                    
-                    for i in range(requests_per_proxy):
-                        if not self.running:
-                            break
-                        
-                        try:
-                            result = self.donate(
-                                self.current_donation_params["company_name"],
-                                self.current_donation_params["country"],
-                                self.current_donation_params["war_id"]
-                            )
-                            print(f"[Proxy: {proxy}] Request {i+1}/{requests_per_proxy}: {result['status']} (Status: {result.get('status_code', 'N/A')})")
-                        except Exception as e:
-                            print(f"[Proxy: {proxy}] Request {i+1}/{requests_per_proxy} failed: {str(e)}")
-                        
-                        time.sleep(1)
-                
-                if self.running:
-                    print(f"Rotation complete. Waiting {delay_after_rotation} seconds...")
-                    for _ in range(delay_after_rotation):
-                        if not self.running:
-                            break
-                        time.sleep(1)
-        
-        self.rotation_thread = threading.Thread(target=rotation_worker)
-        self.rotation_thread.daemon = True
-        self.rotation_thread.start()
-        return self.rotation_thread
-
-    def stop_rotation(self):
-        """Stop the proxy rotation"""
-        self.running = False
-        if self.rotation_thread and self.rotation_thread.is_alive():
-            self.rotation_thread.join(timeout=2)
-        return "Rotation stopped"
-
-    def get_proxy_list(self):
-        """Get the current list of proxies (in ip:port format)"""
-        return [p.replace("http://", "") for p in self.proxies]
-
-    def set_default_param(self, key, value):
-        """
-        Set a default parameter value
-        
-        Args:
-            key (str): Parameter key
-            value (str): Parameter value
-        """
-        if key in self.default_params:
-            self.default_params[key] = value
-            return f"Updated {key}"
-        else:
-            raise KeyError(f"Invalid parameter key: {key}")
-
-    def set_default_header(self, key, value):
-        """
-        Set a default header value
-        
-        Args:
-            key (str): Header key
-            value (str): Header value
-        """
-        self.default_headers[key] = value
-        return f"Updated {key}"

eses-1.0.3/eses/version.py

@@ -1 +0,0 @@
-__version__ = "1.0.3"

eses-1.0.3/tests/test_basic.py

@@ -1,17 +0,0 @@
-import unittest
-import eses
-
-class TestEses(unittest.TestCase):
-    def test_donate(self):
-        result = eses.donate()
-        self.assertIn('status', result)
-        
-    def test_proxy_management(self):
-        initial_count = len(eses.get_proxy_list())
-        eses.add_proxy("http://testproxy.example.com")
-        self.assertEqual(len(eses.get_proxy_list()), initial_count + 1)
-        eses.clear_proxies()
-        self.assertEqual(len(eses.get_proxy_list()), 0)
-
-if __name__ == '__main__':
-    unittest.main()