Add files via upload

Author: ReikaNekoUwU

PyWWW/pywwwget_chatgpt.py

@@ -61,10 +61,7 @@
 import re
 import sys
 import platform
-try:
-    import secrets
-except ImportError:
-    secrets = False
+import secrets
 import socket
 import shutil
 import time
@@ -393,6 +390,13 @@ def unquote(x):  # very small fallback
 except Exception:
     pass
 
+havepycurl = False
+try:
+    import pycurl
+    havepycurl = True
+except ImportError:
+    paass
+
 haveparamiko = False
 try:
     import paramiko  # noqa
@@ -1355,6 +1359,10 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__, ht
         else:
             headers.update({'Referer': httpreferer})
 
+    if(usehttp == "pycurl"):
+        if(isinstance(headers, dict)):
+            headers = make_http_headers_from_dict_to_pycurl(headers)
+
     # Requests
     if usehttp == "requests" and haverequests:
         auth = (username, password) if (username and password) else None
@@ -1459,6 +1467,96 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__, ht
         httpheadersentout = headers
         resp.release_conn()
 
+    elif(usehttp == "pycurl"):
+        retrieved_body = MkTempFile()
+        retrieved_headers = MkTempFile()
+        try:
+            if(httpmethod == "GET"):
+                geturls_text = pycurl.Curl()
+                if(hasattr(pycurl, "CURL_HTTP_VERSION_3_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_3_0
+                elif(hasattr(pycurl, "CURL_HTTP_VERSION_2_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_2_0
+                else:
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_1_1
+                geturls_text.setopt(geturls_text.URL, url)
+                geturls_text.setopt(geturls_text.HTTP_VERSION,
+                                    geturls_text.CURL_HTTP_VERSION_1_1)
+                geturls_text.setopt(
+                    geturls_text.WRITEFUNCTION, retrieved_body.write)
+                geturls_text.setopt(geturls_text.HTTPHEADER, headers)
+                geturls_text.setopt(
+                    geturls_text.HEADERFUNCTION, retrieved_headers.write)
+                geturls_text.setopt(geturls_text.FOLLOWLOCATION, True)
+                geturls_text.setopt(geturls_text.TIMEOUT, 60)
+                geturls_text.perform()
+            elif(httpmethod == "POST"):
+                geturls_text = pycurl.Curl()
+                if(hasattr(pycurl, "CURL_HTTP_VERSION_3_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_3_0
+                elif(hasattr(pycurl, "CURL_HTTP_VERSION_2_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_2_0
+                else:
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_1_1
+                geturls_text.setopt(geturls_text.URL, url)
+                geturls_text.setopt(geturls_text.HTTP_VERSION,
+                                    geturls_text.CURL_HTTP_VERSION_1_1)
+                geturls_text.setopt(
+                    geturls_text.WRITEFUNCTION, retrieved_body.write)
+                geturls_text.setopt(geturls_text.HTTPHEADER, headers)
+                geturls_text.setopt(
+                    geturls_text.HEADERFUNCTION, retrieved_headers.write)
+                geturls_text.setopt(geturls_text.FOLLOWLOCATION, True)
+                geturls_text.setopt(geturls_text.TIMEOUT, 60)
+                geturls_text.setopt(geturls_text.POST, True)
+                geturls_text.setopt(geturls_text.POSTFIELDS, postdata)
+                geturls_text.perform()
+            else:
+                geturls_text = pycurl.Curl()
+                if(hasattr(pycurl, "CURL_HTTP_VERSION_3_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_3_0
+                elif(hasattr(pycurl, "CURL_HTTP_VERSION_2_0")):
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_2_0
+                else:
+                    usehttpver = geturls_text.CURL_HTTP_VERSION_1_1
+                geturls_text.setopt(geturls_text.URL, url)
+                geturls_text.setopt(geturls_text.HTTP_VERSION,
+                                    geturls_text.CURL_HTTP_VERSION_1_1)
+                geturls_text.setopt(
+                    geturls_text.WRITEFUNCTION, retrieved_body.write)
+                geturls_text.setopt(geturls_text.HTTPHEADER, headers)
+                geturls_text.setopt(
+                    geturls_text.HEADERFUNCTION, retrieved_headers.write)
+                geturls_text.setopt(geturls_text.FOLLOWLOCATION, True)
+                geturls_text.setopt(geturls_text.TIMEOUT, 60)
+                geturls_text.perform()
+            retrieved_headers.seek(0, 0)
+            if(sys.version[0] == "2"):
+                pycurlhead = retrieved_headers.read()
+            if(sys.version[0] >= "3"):
+                pycurlhead = retrieved_headers.read().decode('UTF-8')
+            pyhttpverinfo = re.findall(
+                r'^HTTP/([0-9.]+) (\d+)(?: ([A-Za-z\s]+))?$', pycurlhead.splitlines()[0].strip().rstrip('\r\n'))[0]
+            pycurlheadersout = make_http_headers_from_pycurl_to_dict(
+                pycurlhead)
+            retrieved_body.seek(0, 0)
+            httpfile = retrieved_body
+            retrieved_headers.close()
+        except socket.timeout:
+            return False
+        except socket.gaierror:
+            return False
+        except ValueError:
+            return False
+        httpcodeout = geturls_text.getinfo(geturls_text.HTTP_CODE)
+        httpcodereason = http_status_to_reason(
+            geturls_text.getinfo(geturls_text.HTTP_CODE))
+        httpversionout = pyhttpverinfo[0]
+        httpmethodout = httpmethod
+        httpurlout = geturls_text.getinfo(geturls_text.EFFECTIVE_URL)
+        httpheaderout = pycurlheadersout
+        httpheadersentout = headers
+
     # urllib fallback
     else:
         req = Request(rebuilt_url, headers=headers)
@@ -1481,27 +1579,19 @@ def download_file_from_http_file(url, headers=None, usehttp=__use_http_lib__, ht
         try:
             httpcodereason = resp.reason
         except AttributeError:
-            httpcodereason = http_status_to_reason(resp.getcode())
+            httpcodereason = http_status_to_reason(geturls_text.getcode())
         try:
             httpversionout = resp.version
         except AttributeError:
             httpversionout = "1.1"
         try:
             httpmethodout = resp.get_method()
         except AttributeError:
-            try:
-                httpmethodout = resp._method
-            except AttributeError:
-                httpmethodout = httpmethod
+            httpmethodout = resp._method
         httpurlout = resp.geturl()
-        httpheaderout = dict(resp.info())
-        #httpheaderout = dict(resp.headers)
+        httpheaderout = resp.info()
         try:
-            try:
-                httpheadersentout = req.unredirected_hdrs | req.headers
-            except TypeError:
-                httpheadersentout = req.unredirected_hdrs
-                httpheadersentout.update(req.headers)
+            httpheadersentout =  req.unredirected_hdrs | req.headers
         except AttributeError:
             httpheadersentout = req.header_items()
     fulldatasize = httpfile.tell()
@@ -3499,10 +3589,7 @@ def _udp_seq_send(fileobj, host, port, resume=False, path_text=None, **kwargs):
 
     # Start with base timeout; will adapt
     timeout = max(min_to, min(max_to, base_timeout))
-    try:
-        sock.settimeout(timeout)
-    except Exception:
-        pass
+    sock.settimeout(timeout)
 
     chunk = int(kwargs.get("chunk", 1200))
     max_window = int(kwargs.get("window", 32))          # cap
@@ -3520,11 +3607,7 @@ def _udp_seq_send(fileobj, host, port, resume=False, path_text=None, **kwargs):
 
     tid = int(kwargs.get("tid", 0) or 0)
     if tid == 0:
-        # py2/py3 compatible random 64b
-        try:
-            tid = secrets.randbits(64)  # py3.6+
-        except Exception:
-            tid = struct.unpack("!Q", os.urandom(8))[0]
+        tid = secrets.randbits(64)
 
     # stats
     stats = {
@@ -3592,49 +3675,42 @@ def _udp_seq_send(fileobj, host, port, resume=False, path_text=None, **kwargs):
     srtt = None
     rttvar = None
 
-    # PY2/3 replacement for "nonlocal": store mutable state in dict
-    _st = {
-        "srtt": srtt,
-        "rttvar": rttvar,
-        "timeout": timeout,
-        "cwnd": cwnd,
-        "cwnd_float": cwnd_float,
-    }
-
     def _update_rtt(sample):
+        nonlocal srtt, rttvar, timeout
         if sample <= 0:
             return
-        if _st["srtt"] is None:
-            _st["srtt"] = sample
-            _st["rttvar"] = sample / 2.0
+        if srtt is None:
+            srtt = sample
+            rttvar = sample / 2.0
         else:
             # RFC6298-ish
-            alpha = 1.0 / 8.0
-            beta = 1.0 / 4.0
-            _st["rttvar"] = (1 - beta) * _st["rttvar"] + beta * abs(_st["srtt"] - sample)
-            _st["srtt"] = (1 - alpha) * _st["srtt"] + alpha * sample
-
-        _st["timeout"] = _st["srtt"] + 4.0 * _st["rttvar"]
-        _st["timeout"] = max(min_to, min(max_to, _st["timeout"]))
+            alpha = 1 / 8
+            beta = 1 / 4
+            rttvar = (1 - beta) * rttvar + beta * abs(srtt - sample)
+            srtt = (1 - alpha) * srtt + alpha * sample
+        timeout = srtt + 4.0 * rttvar
+        timeout = max(min_to, min(max_to, timeout))
         try:
-            sock.settimeout(_st["timeout"])
+            sock.settimeout(timeout)
         except Exception:
             pass
 
     def _loss_event():
+        nonlocal cwnd, cwnd_float
         stats["loss_events"] += 1
-        _st["cwnd"] = max(1, int(_st["cwnd"]) // 2)
-        _st["cwnd_float"] = float(_st["cwnd"])
+        cwnd = max(1, cwnd // 2)
+        cwnd_float = float(cwnd)
 
     def _ai_increase(acked_count):
         # additive increase: cwnd += acked/cwnd (smoothed)
+        nonlocal cwnd, cwnd_float
         if acked_count <= 0:
             return
-        _st["cwnd_float"] += float(acked_count) / max(1.0, float(_st["cwnd"]))
-        new_cwnd = int(_st["cwnd_float"])
-        if new_cwnd > _st["cwnd"]:
-            _st["cwnd"] = min(max_window, new_cwnd)
-            _st["cwnd_float"] = float(_st["cwnd"])
+        cwnd_float += float(acked_count) / max(1.0, float(cwnd))
+        new_cwnd = int(cwnd_float)
+        if new_cwnd > cwnd:
+            cwnd = min(max_window, new_cwnd)
+            cwnd_float = float(cwnd)
 
     def _send_pkt(seq, wire_payload, flags):
         sock.sendto(_u_pack(flags, seq, total, tid) + wire_payload, addr)
@@ -3654,7 +3730,7 @@ def _read_chunk():
 
     # Prime window
     eof = False
-    while not eof and len(in_flight) < _st["cwnd"]:
+    while not eof and len(in_flight) < cwnd:
         data = _read_chunk()
         if data is None:
             eof = True
@@ -3691,6 +3767,7 @@ def _read_chunk():
                     # Cumulative ACK: drop all <= ack_upto
                     for s in [s for s in list(in_flight.keys()) if s <= ack_upto]:
                         wire, ts, _tries, _dlen = in_flight[s]
+                        # RTT sample from original send timestamp (works best if not retransmitted)
                         sample = now - ts
                         _update_rtt(sample)
                         del in_flight[s]
@@ -3732,7 +3809,7 @@ def _read_chunk():
         now = time.time()
         for seq in list(in_flight.keys()):
             wire, ts, tries, dlen = in_flight[seq]
-            if (now - ts) >= _st["timeout"]:
+            if (now - ts) >= timeout:
                 if tries >= retries:
                     failed = True
                     in_flight.clear()
@@ -3746,7 +3823,7 @@ def _read_chunk():
             break
 
         # Fill window based on cwnd
-        while not eof and len(in_flight) < _st["cwnd"]:
+        while not eof and len(in_flight) < cwnd:
             data = _read_chunk()
             if data is None:
                 eof = True
@@ -3762,10 +3839,10 @@ def _read_chunk():
     dur = max(1e-9, time.time() - t_start)
     stats["duration_s"] = dur
     stats["throughput_Bps"] = float(stats["bytes_sent_payload"]) / dur
-    stats["timeout"] = _st["timeout"]
-    stats["srtt"] = _st["srtt"]
-    stats["rttvar"] = _st["rttvar"]
-    stats["cwnd_end"] = _st["cwnd"]
+    stats["timeout"] = timeout
+    stats["srtt"] = srtt
+    stats["rttvar"] = rttvar
+    stats["cwnd_end"] = cwnd
 
     if failed:
         try: