odaislib 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

k33kz/__init__.py

@@ -328,4 +328,296 @@ class apps:
         response = requests.get("https://www.facebook.com/settings?tab=applications&ref=settings",headers=headers)
         apps_matches = re.findall(r'\",\"app_name\":\"([^\"]+)\",\"', response.text)
         linked_apps = list(set(apps_matches))
-        return linked_apps
+        return linked_apps
+import requests, re, json, time, os, random
+from typing import Optional, Dict, Any, Tuple
+from datetime import datetime
+
+class InstaResetTool:
+    @staticmethod
+    class InstaClient:
+        def __init__(self):
+            self.session = requests.Session()
+            self.csrf_token = None
+            self.response_history = []
+            self.session.headers.update({
+                "User-Agent": "Instagram 320.0.0.34.109 Android (33/13; 420dpi; 1080x2340; samsung; SM-A546B; a54x; exynos1380; en_US; 465123678)",
+                'X-IG-App-Startup-Country': 'US',
+                'X-Bloks-Version-Id': 'ce555e5500576acd8e84a66018f54a05720f2dce29f0bb5a1f97f0c10d6fac48',
+                'X-IG-App-ID': '567067343352427',
+                'X-IG-Connection-Type': 'WIFI',
+                "Accept": "*/*",
+                "Accept-Language": "en-US,en;q=0.9",
+                'accept-encoding': 'gzip, deflate',
+                'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                "Connection": "keep-alive",
+                "Origin": "https://www.instagram.com",
+                "Referer": "https://www.instagram.com/",
+            })
+
+        def cev1(self, text: str) -> Optional[str]:
+            patterns = [
+                r'"csrf_token":"(.*?)"',
+                r'csrftoken=([a-zA-Z0-9]+)',
+            ]
+            for p in patterns:
+                m = re.search(p, text)
+                if m:
+                    self.csrf_token = m.group(1)
+                    self.session.headers["X-CSRFToken"] = self.csrf_token
+                    return self.csrf_token
+            return None
+
+        def cev2(self, url: str) -> Optional[requests.Response]:
+            try:
+                r = self.session.get(url, timeout=10)
+                self.response_history.append({
+                    "timestamp": datetime.now().isoformat(),
+                    "url": url,
+                    "method": "GET",
+                    "status_code": r.status_code,
+                    "cookies": dict(self.session.cookies),
+                    "csrf_token": self.csrf_token
+                })
+                self.cev1(r.text)
+                return r
+            except Exception as e:
+                self.response_history.append({
+                    "timestamp": datetime.now().isoformat(),
+                    "url": url,
+                    "method": "GET",
+                    "error": str(e),
+                    "cookies": dict(self.session.cookies)
+                })
+                return None
+
+        def cev3(self, url: str, data=None, extra_headers=None):
+            headers = self.session.headers.copy()
+            if extra_headers:
+                headers.update(extra_headers)
+
+            try:
+                r = self.session.post(url, data=data, headers=headers, timeout=10)
+                
+                response_data = {
+                    "timestamp": datetime.now().isoformat(),
+                    "url": url,
+                    "method": "POST",
+                    "status_code": r.status_code,
+                    "cookies": dict(self.session.cookies),
+                    "request_data": data,
+                    "content_length": len(r.content),
+                    "response_time": r.elapsed.total_seconds()
+                }
+                
+                self.response_history.append(response_data)
+                
+                if r.status_code == 200 and len(r.content) > 100:
+                    return True, r, response_data
+
+                return False, r, response_data
+
+            except Exception as e:
+                self.response_history.append({
+                    "timestamp": datetime.now().isoformat(),
+                    "url": url,
+                    "method": "POST",
+                    "error": str(e),
+                    "request_data": data,
+                    "cookies": dict(self.session.cookies)
+                })
+                return False, None, None
+    
+    @staticmethod
+    def generate_jazoest(email_or_username: str) -> str:
+        return "21885"
+    
+    @staticmethod
+    def extract_instagram_info(response: requests.Response) -> Dict[str, Any]:
+        info = {
+            "raw_response": response.text if hasattr(response, 'text') else None,
+            "content_length": len(response.content) if hasattr(response, 'content') else 0,
+            "elapsed_time": response.elapsed.total_seconds() if hasattr(response, 'elapsed') else 0,
+            "url": response.url if hasattr(response, 'url') else None,
+        }
+        
+        if hasattr(response, 'headers'):
+            headers = dict(response.headers)
+            info["headers"] = headers
+            
+            instagram_headers = {}
+            for key, value in headers.items():
+                if any(ig_key in key.lower() for ig_key in ['ig', 'instagram', 'x-ig']):
+                    instagram_headers[key] = value
+            info["instagram_headers"] = instagram_headers
+        
+        try:
+            json_data = response.json()
+            info["json_response"] = json_data
+            
+            if isinstance(json_data, dict):
+                info["instagram_status"] = json_data.get("status", "unknown")
+                info["instagram_message"] = json_data.get("message", json_data.get("error_message"))
+                info["instagram_user_id"] = json_data.get("user_id", json_data.get("pk"))
+                info["instagram_username"] = json_data.get("username")
+                info["instagram_email"] = json_data.get("email")
+                info["instagram_challenge_required"] = json_data.get("challenge_required", False)
+                info["instagram_two_factor_required"] = json_data.get("two_factor_required", False)
+                info["instagram_contact_point"] = json_data.get("contact_point")
+                info["instagram_obfuscated_contact_point"] = json_data.get("obfuscated_contact_point")
+                
+                if "checkpoint_url" in json_data:
+                    info["checkpoint_required"] = True
+                    info["checkpoint_url"] = json_data.get("checkpoint_url")
+                if "flow_render_type" in json_data:
+                    info["flow_type"] = json_data.get("flow_render_type")
+                    
+        except:
+            info["json_response"] = None
+            info["raw_text"] = response.text[:500] + "..." if hasattr(response, 'text') and len(response.text) > 500 else response.text if hasattr(response, 'text') else None
+        
+        return info
+
+    def reset_password(self, username: str) -> Dict[str, Any]:
+        client = self.InstaClient()
+
+        client.cev2("https://www.instagram.com/")
+        time.sleep(random.uniform(0.1, 0.2))
+        
+        client.cev2("https://www.instagram.com/accounts/password/reset/")
+        
+        jazoest_value = self.generate_jazoest(username)
+        
+        payload = {
+            "email_or_username": username,
+            "jazoest": jazoest_value,
+        }
+
+        success, response, request_data = client.cev3(
+            "https://www.instagram.com/api/v1/web/accounts/account_recovery_send_ajax/",
+            data=payload,
+            extra_headers={"X-Requested-With": "XMLHttpRequest"}
+        )
+
+        result = {
+            "request_info": {
+                "timestamp": datetime.now().isoformat(),
+                "username": username,
+                "jazoest": jazoest_value,
+                "payload": payload,
+                "endpoint": "https://www.instagram.com/api/v1/web/accounts/account_recovery_send_ajax/",
+                "method": "POST"
+            },
+            
+            "session_info": {
+                "csrf_token": client.csrf_token,
+                "cookies": dict(client.session.cookies),
+                "user_agent": client.session.headers.get("User-Agent"),
+                "app_id": client.session.headers.get("X-IG-App-ID"),
+                "bloks_version": client.session.headers.get("X-Bloks-Version-Id"),
+            },
+            
+            "request_history": client.response_history,
+            
+            "reset_response": {
+                "success": success,
+                "status_code": response.status_code if response else None,
+                "instagram_info": self.extract_instagram_info(response) if response else None,
+            },
+            
+            "response_analysis": {}
+        }
+        
+        if response:
+            analysis = {
+                "is_successful": success,
+                "is_instagram_response": response.status_code == 200 and len(response.content) > 100,
+                "has_json": False,
+                "instagram_status": None,
+                "email_sent": False,
+                "challenge_required": False,
+                "user_exists": None,
+                "possible_errors": []
+            }
+            
+            try:
+                json_data = response.json()
+                analysis["has_json"] = True
+                analysis["instagram_status"] = json_data.get("status")
+                analysis["instagram_message"] = json_data.get("message")
+                
+                if json_data.get("status") == "ok" or json_data.get("message") in ["Email sent", "Password reset email sent"]:
+                    analysis["email_sent"] = True
+                
+                if json_data.get("status") == "ok":
+                    analysis["user_exists"] = True
+                elif "user" in json_data.get("message", "").lower() or "account" in json_data.get("message", "").lower():
+                    analysis["user_exists"] = False
+                    analysis["possible_errors"].append("USER_NOT_FOUND")
+                
+                if json_data.get("challenge_required") or json_data.get("checkpoint_url"):
+                    analysis["challenge_required"] = True
+                    analysis["possible_errors"].append("CHALLENGE_REQUIRED")
+                    
+            except:
+                pass
+            
+            if response.status_code == 200:
+                analysis["possible_errors"].append("NONE")
+            elif response.status_code == 400:
+                analysis["possible_errors"].append("BAD_REQUEST")
+            elif response.status_code == 403:
+                analysis["possible_errors"].append("FORBIDDEN")
+            elif response.status_code == 429:
+                analysis["possible_errors"].append("RATE_LIMIT")
+            elif response.status_code >= 500:
+                analysis["possible_errors"].append("SERVER_ERROR")
+            
+            result["response_analysis"] = analysis
+        
+        result["summary"] = {
+            "username": username,
+            "request_made": True,
+            "instagram_responded": response is not None,
+            "final_status": "SUCCESS" if success else "FAILED" if response else "ERROR",
+            "email_possibly_sent": result.get("response_analysis", {}).get("email_sent", False),
+            "user_likely_exists": result.get("response_analysis", {}).get("user_exists"),
+            "timestamp_completed": datetime.now().isoformat(),
+            "total_time": sum(item.get("response_time", 0) for item in client.response_history if "response_time" in item)
+        }
+        
+        return result
+
+    def get_full_response(self, username: str) -> Dict[str, Any]:
+        return self.reset_password(username)
+
+    def analyze_response_only(self, response_text: str) -> Dict[str, Any]:
+        class MockResponse:
+            def __init__(self, text):
+                self.text = text
+                self.content = text.encode('utf-8') if text else b''
+                self.headers = {}
+                self.status_code = 200
+                self.elapsed = type('obj', (object,), {'total_seconds': lambda: 0})()
+                self.url = "https://www.instagram.com/api/v1/web/accounts/account_recovery_send_ajax/"
+        
+        mock_response = MockResponse(response_text)
+        return self.extract_instagram_info(mock_response)
+
+
+def cev6(usernames) -> Dict[str, Any]:
+    tool = InstaResetTool()
+    
+    if isinstance(usernames, str):
+        username = usernames
+    elif isinstance(usernames, list) and len(usernames) > 0:
+        username = usernames[0]
+    else:
+        return {"status": "error", "message": "Invalid username input"}
+    
+    return tool.reset_password(username)
+
+
+def reset_password(username: str) -> Dict[str, Any]:
+    tool = InstaResetTool()
+    return tool.reset_password(username)

{odaislib-1.0.4.dist-info → odaislib-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: odaislib
-Version: 1.0.4
+Version: 1.0.6
 Summary: Facebook Authentication Library with multiple login methods
 Home-page: 
 Author: Odai

odaislib-1.0.6.dist-info/RECORD

@@ -0,0 +1,5 @@
+k33kz/__init__.py,sha256=g3AIzSynEOFVQ8GyT5Sfqg9WdDIU2U7a65KyxIR98XI,28174
+odaislib-1.0.6.dist-info/METADATA,sha256=hboPkqcIhNTp0qcrvHJXlt7CdBAyxKFPH0yvLkJFv-A,941
+odaislib-1.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+odaislib-1.0.6.dist-info/top_level.txt,sha256=3wvp4V0a1Vuwng0HAuy3i2gDSQrn0GznidyGoby2Gcc,6
+odaislib-1.0.6.dist-info/RECORD,,

odaislib-1.0.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-k33kz/__init__.py,sha256=mivxa7fql9SzLkrmX1h187qT-1YC4VHukikXkUXZJKI,15691
-odaislib-1.0.4.dist-info/METADATA,sha256=tUiUE-sGI1PtIRCEefSjLKg3aloMc11cCbjEx78AXfA,941
-odaislib-1.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-odaislib-1.0.4.dist-info/top_level.txt,sha256=3wvp4V0a1Vuwng0HAuy3i2gDSQrn0GznidyGoby2Gcc,6
-odaislib-1.0.4.dist-info/RECORD,,