optimuslib 0.0.45__tar.gz → 0.0.47__tar.gz

{optimuslib-0.0.45 → optimuslib-0.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: optimuslib
-Version: 0.0.45
+Version: 0.0.47
 Summary: Function Library for mostly used codes
 Author: Shomi Nanwani
 Requires-Python: >=3.9,<4.0
@@ -9,10 +9,12 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: pillow (==9.5.0)
 Requires-Dist: pyperclip (>=1.8.2,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: requests-futures (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown
 
-
+Optimuslib

optimuslib-0.0.47/README.md

@@ -0,0 +1 @@
+Optimuslib

{optimuslib-0.0.45 → optimuslib-0.0.47}/optimuslib/optimuslib.py

@@ -24,7 +24,8 @@
 #########################################################
 # Local testing on 
 # C:\Users\Admin\AppData\Local\Programs\Python\Python311\Lib\site-packages\optimuslib
-# /home/pi/.local/lib/python3.9/site-packages/optimuslib/optimuslib.py
+# /home/pi/.local/lib/python3.11/site-packages/optimuslib/optimuslib.py
+# ~/.local/lib/python3.11/site-packages/optimuslib/optimuslib.py
 
 ### import code
 # import optimuslib
@@ -93,19 +94,6 @@
 # python -m pip install --no-cache-dir  --upgrade -r requirements.txt
 
 
-###### CHECK OS AND PERFORM COMMAND ACCORDINGLY
-# get OS version
-import platform
-def checkOS():
-    osType = platform.system()
-    osVersion = platform.platform()
-    oshostname = platform.node()
-    # log.info('osType: %s, osVersion: %s, oshostname: %s', osType, osVersion, oshostname)
-    print(f'osType: {osType}, osVersion: {osVersion}, oshostname: {oshostname}')
-    return osType, osVersion, oshostname
-
-
-
 
 ############## LOG INFO IN TERMINAL AND log.txt FILE ###################
 import logging
@@ -144,6 +132,17 @@ def loglib(data):
     log.info('%d %s' % ('1', 'a'))
     log.info('%d %s' % '1' % 'a')
 
+###### CHECK OS AND PERFORM COMMAND ACCORDINGLY
+# get OS version
+import platform
+def checkOS():
+    osType = platform.system()
+    osVersion = platform.platform()
+    oshostname = platform.node()
+    # log.info('osType: %s, osVersion: %s, oshostname: %s', osType, osVersion, oshostname)
+    log.info(f'osType: {osType}, osVersion: {osVersion}, oshostname: {oshostname}')
+    return osType, osVersion, oshostname
+
 
 osType, osVersion, oshostname = checkOS()
 if osType == 'Windows':
@@ -251,6 +250,7 @@ def traverse(path):
  
 # '''
 ############## REQUESTS LIBRARY ###################
+'''
 import time, sys, requests
 # import sys
 import requests
@@ -335,11 +335,11 @@ def sendRequest(method, requestUrl, cookies=None, headers=None, data=None, json=
         s.proxies = { 'http': proxyhost, 'https': proxyhost}
         # pythonproxy.parseProxyHostAndRun(proxyhost)
 
-    '''
-    if not validResponseCodes:
-        # validResponseCodes = [200,201,302,307,401,400,403,404,405,406]
-        validResponseCodes = [200,201,302,307,401,400,404,405,406]
-    '''
+'''
+    # if not validResponseCodes:
+    #     # validResponseCodes = [200,201,302,307,401,400,403,404,405,406]
+    #     validResponseCodes = [200,201,302,307,401,400,404,405,406]
+'''
     totalRequestsSent += 1
     
     # log.info('[%d/%d] Sending Request: %s',totalRequestsSent,len(requestUrl),requestUrl)
@@ -365,8 +365,8 @@ def sendRequest(method, requestUrl, cookies=None, headers=None, data=None, json=
     # except (MalformedRequest, InternalError, StatusUnknown, ConnectionError, ConnectionResetError, http.client.RemoteDisconnected, RemoteDisconnected, ProtocolError, HTTPException, socket.gaierror) as e:
     except requests.exceptions.ConnectionError as e:
         log.error(f'ConnectionError occured - {e}')
-        print('Sleeping for 60 secods before next request')
-        time.sleep(60)
+        log.error('Sleeping for 15 secods before next request')
+        time.sleep(15)
         sendRequest(method, requestUrl, cookies, headers, data, json, params, files, timeout, proxyhost, validResponseCodes, allow_redirects, verify)
         # sys.exit()
     except requests.exceptions.ConnectionResetError as e:
@@ -374,7 +374,7 @@ def sendRequest(method, requestUrl, cookies=None, headers=None, data=None, json=
         log.error('Is your internet connection Stable?')
         sys.exit()
     except requests.exceptions.RequestException as e:
-        print(f"Request failed: {e}")
+        log.error(f"Request failed: {e}")
     except ConnectionRefusedError as e:
         log.error(f'Exception occured - {e}')
         log.error('Is proxy set and server not running?')
@@ -419,6 +419,122 @@ def sendBulkRequests(method, requestUrlList, cookies=None, headers=None, data=No
 
 ################# REQUESTS MODULE DEBUGGING
 '''
+########## CORRECTED BY CHATGPT
+import time, sys, requests, logging
+from requests.adapters import HTTPAdapter, Retry
+from requests_futures.sessions import FuturesSession
+requests.packages.urllib3.disable_warnings()
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+log = logging.getLogger(__name__)
+
+# Response codes to force retry on
+RETRY_STATUS_CODES = [429, 500, 502, 503, 504]
+
+# Max retry attempts
+MAX_RETRIES = 5
+
+# Futures Session for parallel async requests
+futuresworkercount = 100
+s = FuturesSession(max_workers=futuresworkercount)
+
+# Configure retry strategy
+retry_strategy = Retry(
+    total=MAX_RETRIES,
+    backoff_factor=1,  # Exponential backoff: 1,2,4,8...
+    status_forcelist=RETRY_STATUS_CODES,
+    allowed_methods=["HEAD", "GET", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"],
+    raise_on_status=False
+)
+
+adapter = HTTPAdapter(max_retries=retry_strategy)
+s.mount("https://", adapter)
+s.mount("http://", adapter)
+
+totalRequestsSent = 0
+
+
+def _handle_429(response, attempt):
+    """Handles 429 Too Many Requests with delay/retry."""
+    if response.status_code != 429:
+        return False
+
+    retry_after = response.headers.get("Retry-After")
+    if retry_after:
+        delay = int(retry_after)
+    else:
+        delay = min(2 ** attempt, 60)  # exponential backoff, max 60s
+
+    log.warning(f"429 Too Many Requests - sleeping {delay}s before retry...")
+    time.sleep(delay)
+    return True
+
+
+def sendRequest(method, requestUrl, cookies=None, headers=None, data=None, json=None, params=None, files=None, timeout=None, proxyhost=None, allow_redirects=True, verify=False):
+    """Send HTTP request with retry + 429 handling."""
+    global totalRequestsSent
+    totalRequestsSent += 1
+
+    if proxyhost:
+        log.debug('Using proxy: %s', proxyhost)
+        s.proxies = {'http': proxyhost, 'https': proxyhost}
+
+    log.debug(f'[{totalRequestsSent}] Sending Request: {requestUrl}')
+
+    method = method.lower()
+    attempts = 0
+
+    while attempts < MAX_RETRIES:
+        try:
+            if method == "get":
+                response = s.get(requestUrl, cookies=cookies, headers=headers, params=params, timeout=timeout, allow_redirects=allow_redirects, verify=verify)
+            elif method == "post":
+                response = s.post(requestUrl, cookies=cookies, headers=headers, data=data, json=json, files=files, params=params, timeout=timeout, allow_redirects=allow_redirects, verify=verify)
+            elif method == "patch":
+                response = s.patch(requestUrl, cookies=cookies, headers=headers, data=data, json=json, files=files, params=params, timeout=timeout, allow_redirects=allow_redirects, verify=verify)
+            elif method == "delete":
+                response = s.delete(requestUrl, cookies=cookies, headers=headers, data=data, json=json, files=files, params=params, timeout=timeout, allow_redirects=allow_redirects, verify=verify)
+            elif method == "put":
+                response = s.put(requestUrl, cookies=cookies, headers=headers, data=data, json=json, files=files, params=params, timeout=timeout, allow_redirects=allow_redirects, verify=verify)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+
+            result = response.result()
+
+            # Handle 429 manually
+            if result.status_code == 429:
+                if _handle_429(result, attempts):
+                    attempts += 1
+                    continue
+
+            log.debug(f"Response [{result.status_code}] - {result.text}...")
+            # log.debug(f"Response [{result.status_code}] - {result.text[:200]}...")
+            return response
+
+        except requests.exceptions.ConnectionError as e:
+            log.error(f'ConnectionError: {e} - retrying in 5s...')
+            time.sleep(5)
+        except requests.exceptions.RequestException as e:
+            log.error(f"Request failed: {e}")
+            break
+
+        attempts += 1
+
+    log.error(f"Request failed after {MAX_RETRIES} attempts: {requestUrl}")
+    return None
+
+
+def sendBulkRequests(method, requestUrlList, **kwargs):
+    """Send multiple requests in bulk."""
+    futureResponseList = []
+    for idx, requestUrl in enumerate(requestUrlList, 1):
+        log.debug(f'Sending Bulk Request...[{idx}/{len(requestUrlList)}]')
+        futureResponse = sendRequest(method, requestUrl, **kwargs)
+        futureResponseList.append(futureResponse)
+    return futureResponseList
+########### CORRECTED BY CHATGPT
+'''
 # GET ALL COOKIES IN SESSION
 print(s.cookies.get_dict())
 
@@ -922,7 +1038,7 @@ def select_file_from_computer(image_path):
     autoit.win_active("Open")
     autoit.control_set_text("Open", "Edit1", image_path)
     autoit.control_send("Open", "Edit1", "{ENTER}")
-    log.info("Sleeping for %s seconds...", wait_time)
+    log.info(f"Sleeping for {wait_time} seconds...", )
     sleep(wait_time)
     
 # click_function('Sign In',"//a[@data-nav-ref='nav_ya_signin']",)
@@ -932,11 +1048,13 @@ def select_file_from_computer(image_path):
 ############################
 import os
 def createFolder(foldername):
-    try:
-        if os.mkdir(foldername):
-            log.info('Folder Created: %s', foldername)
-    except FileExistsError:
-        log.info('%s folder already exists', foldername)
+    # try:
+    #     if os.mkdir(foldername):
+    #         log.info(f"Folder Created: {foldername}")
+    # except FileExistsError:
+    #     log.info(f"{foldername} folder already exists")
+    if not os.path.exists(foldername):
+        os.makedirs(foldername)
 
 ############################
 import re
@@ -1140,13 +1258,13 @@ def textfile_to_image(text_file_path, image_output_path):
     for font_filename in COMMON_MONO_FONT_FILENAMES:
         try:
             font = ImageFont.truetype(font_filename, size=large_font)
-            print(f'Using font "{font_filename}".')
+            log.error(f'Using font "{font_filename}".')
             break
         except IOError:
-            print(f'Could not load font "{font_filename}".')
+            log.error(f'Could not load font "{font_filename}".')
     if font is None:
         font = ImageFont.load_default()
-        print('Using default font.')
+        log.error('Using default font.')
 
     # make a sufficiently sized background image based on the combination of font and lines
     font_points_to_pixels = lambda pt: round(pt * 96.0 / 72)
@@ -1206,28 +1324,34 @@ def logAndSend(botToken,chatId,output):
     sendDiscordBotNotification(botToken,chatId,output)
 
 ########## format a number as per indian currency 
-def formatCurrrencyIndian(number):
-    # Convert the number to string and split it into the integer and decimal parts
+def formatCurrencyIndian(number):
+    """
+    Format a number as per Indian currency format with commas.
+    Example: 12345678.90 -> '1,23,45,678.90'
+    """
     number_str = "{:.2f}".format(number)
     integer_part, decimal_part = number_str.split(".")
-    
-    # Reverse the integer part for easier grouping
-    integer_part_reversed = integer_part[::-1]
-    
-    # Group the digits in the Indian numbering system (3,2,2,...)
-    groups = []
-    groups.append(integer_part_reversed[:3])
-    groups.append(integer_part_reversed[3:5])
-    for i in range(5, len(integer_part_reversed), 2):
-        groups.append(integer_part_reversed[i:i+2])
-    
-    # Join the groups with commas and reverse back
-    indian_number_format = ",".join(groups)[::-1]
-    
-    # Combine integer part with decimal part
-    formatted_number = indian_number_format + "." + decimal_part
-    
-    return formatted_number
+    # Handle negative numbers
+    sign = ""
+    if integer_part.startswith('-'):
+        sign = "-"
+        integer_part = integer_part[1:]
+
+    # First group (last 3 digits)
+    if len(integer_part) > 3:
+        last3 = integer_part[-3:]
+        rest = integer_part[:-3]
+        # Group rest in pairs
+        pairs = []
+        while len(rest) > 2:
+            pairs.insert(0, rest[-2:])
+            rest = rest[:-2]
+        if rest:
+            pairs.insert(0, rest)
+        formatted = sign + ",".join(pairs + [last3]) + "." + decimal_part
+    else:
+        formatted = sign + integer_part + "." + decimal_part
+    return formatted
 
 ########### DISCORD BOT NOTIFICATION - BOT DETAILS ##############
 # def getDiscordBotInfo(botToken):
@@ -1325,6 +1449,9 @@ def fetchOTPDiscord(botToken, otpFetchWaitTime, otpChannelId):
             id, timestamp, username, content = getDiscordBotUpdates(botToken, otpChannelId, messageCount=1)
             log.info('update_id: %s, text: %s', id, content)
             twofa_value = content[-6:]
+            twofa_value = twofa_value.replace("-","")
+            twofa_value = twofa_value.replace("S","")
+            twofa_value = twofa_value.replace("T","")
             getVarInfo('twofa_value',twofa_value)
             break
         except ValueError as e:
@@ -1410,6 +1537,132 @@ def buildUnicodeTable(headers, rows):
 # fetchOTPDiscord(botToken, otpFetchWaitTime, otpChannelId)
 # sendDiscordBotNotification(botToken,channelId,message)
 # sendDiscordBotFile(botToken,channelId,filePath)
+
+
+########################## FETCH OTP FROM GMAIL VIA APP PASSWORD ##########################
+import imaplib
+import email
+import time
+import re
+import quopri
+import threading
+from bs4 import BeautifulSoup
+from email.utils import parsedate_to_datetime
+from datetime import datetime, timezone
+
+
+def extract_clean_text(msg):
+    """Extract readable text from HTML email"""
+    text = ""
+    for part in msg.walk():
+        if part.get_content_type() == "text/html":
+            raw = part.get_payload(decode=True)
+            decoded = quopri.decodestring(raw).decode(errors="ignore")
+            soup = BeautifulSoup(decoded, "html.parser")
+            text += soup.get_text(" ")
+    return text
+
+
+def is_recent(msg):
+    """Check if email was received within MAX_AGE_SECONDS"""
+    date_hdr = msg.get("Date")
+    if not date_hdr:
+        return False
+
+    try:
+        msg_time = parsedate_to_datetime(date_hdr)
+        if msg_time.tzinfo is None:
+            msg_time = msg_time.replace(tzinfo=timezone.utc)
+
+        now = datetime.now(timezone.utc)
+        age = (now - msg_time).total_seconds()
+        return 0 <= age <= MAX_AGE_SECONDS
+    except Exception:
+        return False
+
+
+def input_with_timeout(prompt, timeout):
+    """Get user input with timeout"""
+    result = {"value": None}
+
+    def ask():
+        try:
+            result["value"] = input(prompt)
+        except EOFError:
+            pass
+
+    t = threading.Thread(target=ask, daemon=True)
+    t.start()
+    t.join(timeout)
+
+    return result["value"]
+
+
+# ============== IMAP OTP ==================
+
+def poll_for_otp(EMAIL, APP_PASSWORD, SENDER, SUBJECT, POLL_INTERVAL, POLL_TIMEOUT, MAX_AGE_SECONDS):
+    """Poll Gmail IMAP for OTP email"""
+    IMAP_SERVER = "imap.gmail.com"
+    mail = imaplib.IMAP4_SSL(IMAP_SERVER)
+    mail.login(EMAIL, APP_PASSWORD)
+
+    start = time.time()
+
+    while time.time() - start < POLL_TIMEOUT:
+        # 🔑 Gmail IMAP requires re-select to refresh UNSEEN
+        mail.select("inbox", readonly=False)
+
+        status, messages = mail.search(
+            None,
+            f'(UNSEEN FROM "{SENDER}" SUBJECT "{SUBJECT}")'
+        )
+
+        ids = messages[0].split()
+
+        for eid in ids:
+            _, data = mail.fetch(eid, "(RFC822)")
+            msg = email.message_from_bytes(data[0][1])
+
+            if not is_recent(msg):
+                continue
+
+            body = extract_clean_text(msg)
+            match = re.search(r"OTP[^0-9]*(\d{6})", body, re.IGNORECASE)
+
+            if match:
+                # mark email as read
+                mail.store(eid, "+FLAGS", "\\Seen")
+                mail.logout()
+                return match.group(1)
+
+        log.info("Waiting for OTP...")
+        time.sleep(POLL_INTERVAL)
+
+    mail.logout()
+    raise TimeoutError("Auto OTP fetch timed out")
+
+
+def get_gmail_otp(EMAIL, APP_PASSWORD, SENDER, SUBJECT,POLL_INTERVAL,POLL_TIMEOUT,MAX_AGE_SECONDS,MANUAL_INPUT_TIMEOUT):
+    """Get OTP automatically or fall back to manual input"""
+    try:
+        otp = poll_for_otp(EMAIL, APP_PASSWORD, SENDER, SUBJECT, POLL_INTERVAL, POLL_TIMEOUT, MAX_AGE_SECONDS)
+        log.info("OTP received automatically:", otp)
+        return otp
+
+    except TimeoutError:
+        log.info("⚠️ Auto OTP fetch timed out.")
+        log.info(f"Please enter OTP manually (waiting {MANUAL_INPUT_TIMEOUT} seconds)...")
+
+        manual_otp = input_with_timeout("Enter OTP: ", MANUAL_INPUT_TIMEOUT)
+
+        if manual_otp and manual_otp.strip().isdigit():
+            return manual_otp.strip()
+
+        raise TimeoutError("No OTP entered within manual input window")
+
+# ================== RUN ===================
+
+
 ################################################
 log.info('[+] Optimuslib Import Sucessfull.')
 

{optimuslib-0.0.45 → optimuslib-0.0.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "optimuslib"
-version = "0.0.45"
+version = "0.0.47"
 description = "Function Library for mostly used codes"
 authors = ["Shomi Nanwani"]
 readme = "README.md"