eses 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

eses/__init__.py

@@ -3,185 +3,202 @@ import time
 from itertools import cycle
 import threading
 
-# Default configuration
-api_url = "http://52.24.104.170:8086/RestSimulator"
-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"
-}
+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"
+        }
 
-default_headers = {
-    "Host": "52.24.104.170:8086",
-    "Connection": "Keep-Alive",
-    "User-Agent": "android-async-http",
-    "Accept-Encoding": "gzip",
-    "Content-Length": "0"
-}
+        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
-proxies = []
-proxy_cycle = None
-running = False
-rotation_thread = None
+        # Proxy management
+        self.proxies = []
+        self.proxy_cycle = None
+        self.running = False
+        self.rotation_thread = None
+        self.current_donation_params = {}
 
-def donate(company_name="EPSAT", country="Bulgaria", war_id="55032"):
-    """
-    Send a donation request with customizable parameters
-    
-    Args:
-        company_name (str): Name of the company (default: "EPSAT")
-        country (str): Country name (default: "Bulgaria")
-        war_id (str): War ID (default: "55032")
+    def donate(self, company_name, country, war_id):
+        """
+        Send a donation request with required parameters
         
-    Returns:
-        dict: Dictionary containing status, status_code, and response/error
-    """
-    params = default_params.copy()
-    params.update({
-        "company_name": company_name,
-        "country": country,
-        "war_id": war_id
-    })
-    
-    try:
-        response = requests.get(
-            api_url,
-            params=params,
-            headers=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)
+        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
         }
 
-def add_proxy(proxy):
-    """
-    Add a proxy to the proxy list
-    
-    Args:
-        proxy (str): Proxy address in format 'http://host:port' or 
-                    'http://username:password@host:port'
-    """
-    if proxy not in proxies:
-        proxies.append(proxy)
-        global proxy_cycle
-        proxy_cycle = cycle(proxies)
-        return f"Proxy added: {proxy}"
-    return f"Proxy already exists: {proxy}"
+        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():
-    """Clear all proxies from the proxy list"""
-    global proxies, proxy_cycle
-    proxies = []
-    proxy_cycle = None
-    return "All proxies cleared"
+    def clear_proxies(self):
+        """Clear all proxies from the proxy list"""
+        self.proxies = []
+        self.proxy_cycle = None
+        return "All proxies cleared"
 
-def proxyrotate(requests_per_proxy=3, delay_between_rotations=20):
-    """
-    Rotate through proxies making requests
-    
-    Args:
-        requests_per_proxy (int): Number of requests to make per proxy (default: 3)
-        delay_between_rotations (int): Seconds to wait between full rotations (default: 20)
+    def rotateproxy(self, requests_per_proxy=None, delay_after_rotation=None):
+        """
+        Rotate through proxies making requests using current donation parameters
         
-    Returns:
-        threading.Thread: The rotation thread object
-    """
-    global running, proxy_cycle, rotation_thread
-    
-    if not proxies:
-        raise ValueError("No proxies available. Add proxies using add_proxy()")
-    
-    if proxy_cycle is None:
-        proxy_cycle = cycle(proxies)
-    
-    running = True
-    
-    def rotation_worker():
-        while running:
-            for proxy in proxies:
-                if not running:
-                    break
-                
-                proxy_config = {
-                    'http': proxy,
-                    'https': proxy
-                }
-                
-                for i in range(requests_per_proxy):
-                    if not running:
-                        break
-                    
-                    try:
-                        result = donate()
-                        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)  # Small delay between requests
+        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 running:
-                print(f"Rotation complete. Waiting {delay_between_rotations} seconds...")
-                for _ in range(delay_between_rotations):
-                    if not running:
+        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
-                    time.sleep(1)
-    
-    rotation_thread = threading.Thread(target=rotation_worker)
-    rotation_thread.daemon = True
-    rotation_thread.start()
-    return rotation_thread
+                    
+                    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():
-    """Stop the proxy rotation"""
-    global running
-    running = False
-    if rotation_thread and rotation_thread.is_alive():
-        rotation_thread.join(timeout=2)
-    return "Rotation stopped"
+    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():
-    """Get the current list of proxies"""
-    return proxies.copy()
+    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(key, value):
-    """
-    Set a default parameter value
-    
-    Args:
-        key (str): Parameter key
-        value (str): Parameter value
-    """
-    if key in default_params:
-        default_params[key] = value
-        return f"Updated {key}"
-    else:
-        raise KeyError(f"Invalid parameter key: {key}")
+    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(key, value):
-    """
-    Set a default header value
-    
-    Args:
-        key (str): Header key
-        value (str): Header value
-    """
-    default_headers[key] = value
-    return f"Updated {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}"
 
-# Initialize proxy cycle if proxies exist
-if proxies:
-    proxy_cycle = cycle(proxies)
+# Create a module-level instance for the simple interface
+eses = ESES()

eses/version.py

@@ -1 +1 @@
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{eses-1.0.0.dist-info → eses-1.0.2.dist-info}/METADATA

@@ -1,15 +1,23 @@
 Metadata-Version: 2.4
 Name: eses
-Version: 1.0.0
-Summary: A library for sending donations through proxies
-Author-email: entente <your@email.com>
+Version: 1.0.2
+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
-Project-URL: Bug-Tracker, https://github.com/yourusername/eses/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: requests>=2.25.0
+Dynamic: license-file
+
+# eses Python Package
+
+A library for sending donation requests with proxy rotation capabilities.
+
+## Installation
+
+```bash
+pip install eses

eses-1.0.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+eses/__init__.py,sha256=QbmbQ1668_tQpdUUZ3vlGeLwaitoN_lD9_LYhNkSE1I,7306
+eses/version.py,sha256=JqmBIiZnO_c1ce6zv6JZzf01tRk6jFq-SGGuvkL_r1U,21
+eses-1.0.2.dist-info/licenses/LICENSE,sha256=aG4OK9mj5S-wNkDBtWV4cDftgrzOM901qqYwlGF2Q2U,1085
+eses-1.0.2.dist-info/METADATA,sha256=WOAvu9PHyfrrc0dYXwlRxyTDIs77MaYxzCWqLY47YOU,667
+eses-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+eses-1.0.2.dist-info/top_level.txt,sha256=bhF_PMTvXEr3zbQtvND1twvnv1MQUq2hcn8kREYmePw,5
+eses-1.0.2.dist-info/RECORD,,

eses-1.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eses-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-eses/__init__.py,sha256=I7BxNQHWFA1D9Aaq6GyVQeIZWEK0iX8dEAJDwsqacbs,5436
-eses/version.py,sha256=Aj77VL1d5Mdku7sgCgKQmPuYavPpAHuZuJcy6bygQZE,21
-eses-1.0.0.dist-info/METADATA,sha256=2Dezt7vC14EO2GqlG7BzndzFTnQhF34jgqiMRzg2K28,629
-eses-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-eses-1.0.0.dist-info/top_level.txt,sha256=bhF_PMTvXEr3zbQtvND1twvnv1MQUq2hcn8kREYmePw,5
-eses-1.0.0.dist-info/RECORD,,