ghttp-tool 0.0.1__py3-none-any.whl

ghttp/__init__.py

@@ -0,0 +1,14 @@
+"""
+GHTTP By GPGStudio created for easy work with http,
+See everything in "README"
+"""
+
+from .parsearg import parsearg, parse, unparse
+from .server import server, tserver
+from .client import client
+from .transfer_encoding import read as transfer_encoding
+from .simple_client import get, head, post, put, delete, connect, options, trace, patch, Session, parseurl
+from .simple_server import serve
+
+__all__ = ['parsearg','parse','unparse','server','tserver','client','transfer_encoding','get','head','post','put','delete','connect','options','trace','patch','Session','serve','parseurl']
+__version__ = '0.0.1'

ghttp/client.py

@@ -0,0 +1,134 @@
+from .transfer_encoding import read as read_encoding
+import socket
+
+def read(s):
+    try:
+        data = s.recv(65500)
+        while b'\r\n\r\n' not in data:
+            chunk = s.recv(65500)
+            if chunk == b'':
+                break
+            data += chunk
+    except: data = b''
+    if not data == b'':
+        data_split = data.find(b'\r\n\r\n')
+        header, dta = data[:data_split], data[data_split+4:]
+        headers = {}
+        h = header.split(b'\r\n')
+        answer = h[0].split(b' ',1)
+        answer = answer[0].decode(), answer[1].decode()
+        for i in h[1:]:
+            key, value = i.split(b':',1)
+            key = key.decode(errors='replace')
+            value = value.lstrip(b' ').decode(errors='replace')
+            headers[key.lower()] = int(value) if value.isdigit() else value
+        if 'transfer-encoding' in headers:
+            dta = read_encoding(s,dta,headers['transfer-encoding'])
+        elif 'content-length' in headers:
+            toread = headers['content-length']
+            toread = int(toread) - len(dta)
+            while toread > 0:
+                chunk = s.recv(toread if toread < 65500 else 65500)
+                dta += chunk
+                toread -= len(chunk)
+        else:
+            s.settimeout(0.5)
+            while True:
+                try: chunk = s.recv(65500)
+                except: break
+                if chunk == b'':
+                    break
+                dta += chunk
+            s.settimeout(5.0)
+        return answer, dta, headers
+    else:
+        return [None, None], None, {}
+
+def send(s, method='GET', path='/', ver='1.1', data=b'', headers={}, without_len=False, encoding='utf-8'):
+    if type(data)==str:
+        data = data.encode(encoding=encoding)
    result = f"{method} {path} HTTP/{ver}\x0d\x0a" 
+    for key, value in headers.items():
        result += f"{key}: {value}\x0d\x0a"
    if not without_len:
        if not "\ncontent-length: " in result.lower():
            result += f"Content-Length: {len(data)}\x0d\x0a"
    result += "\x0d\x0a"
    data = result.encode() + data
    s.sendall(data)
+
+def send_raw(conn, data):
+    if type(data)==bytes:
+        conn.sendall(data)
+    else:
+        raise ValueError("data must be bytes!")
+
+def read_chunk(conn):
+    try:
+        chunk_size_hex = b''
+        while True:
+            char = conn.recv(1)
+            if not char:
+                return None
+            if char == b'\n':
+                break
+            chunk_size_hex += char
+        if chunk_size_hex.endswith(b'\r'):
+            chunk_size_hex = chunk_size_hex[:-1]
+        try:
+            chunk_size = int(chunk_size_hex, 16)
+        except ValueError:
+            return None
+        if chunk_size == 0:
+            conn.recv(2)
+            return (b'', 0)
+        data = b''
+        while len(data) < chunk_size:
+            remaining = chunk_size - len(data)
+            chunk = conn.recv(min(remaining, 8192))
+            if not chunk:
+                return None
+            data += chunk
+        conn.recv(2)
+        return data, chunk_size
+    except Exception:
+        return None, None
+
+def send_chunk(conn, data):
+    if type(data)==bytes:
+        conn.sendall(hex(len(data))[2:].encode() + b'\r\n' + data + b'\r\n')
+    else:
+        raise ValueError("data must be bytes!")
+
+def read_raw(s, data=None):
+    try: return s.recv(data)
+    except: return None
+
+def close(s):
+    try: s.close()
+    except: pass
+
+class client:
+    def __init__(self, VER='1.1'):
+        self.ver = VER
+        self.s = None
+        pass
+    def connect(self, IP='localhost', PORT=80, CUSTOM_SOCK=None):
+        try: self.s.close()
+        except: pass
+        try:
+            if CUSTOM_SOCK is None:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            else:
+                s = CUSTOM_SOCK
+            s.settimeout(5.0)
+            s.connect((IP,PORT))
+            self.s = s
+        except: pass
+    def read(self):
+        return read(self.s)
+    def send(self, method='GET', path='/', data=b'', headers={}, without_len=False):
+        send(self.s, method, path, self.ver, data, headers, without_len)
+    def send_raw(self, data):
+        send_raw(self.s, data)
+    def send_chunk(self, data):
+        send_chunk(self.s, data)
+    def read_chunk(self):
+        return read_chunk(self.s)
+    def read_raw(self, data=None):
+        return read_raw(self.s, data)
+    def close(self):
+        close(self.s)
+    

ghttp/parsearg.py

@@ -0,0 +1,43 @@
+def parse(data, safe='1234567890-+_.~qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'):
+    value = ''
+    for i in data.encode():
+        if bytes([i]) in safe.encode():
+            value += bytes([i]).decode()
+        else:
+            value += f'%{bytes([i]).hex().upper()}'
+    return value
+def unparse(data):
+    for i in range(0,256):
+        data = data.replace(f'%{bytes([i]).hex()}',chr(i)).replace(f'%{bytes([i]).hex().upper()}',chr(i))
+    return data
+def parsearg(data,continius=None,encoding='utf-8',safe='1234567890-+_.~qwertyuiopasdfghjklzxcvbnm'):
+    if isinstance(continius, dict):
+        toret = '?'
+        for key, _value in continius.items():
+            value = parse(_value)
+            toret += f'{key}={value}&'
+        return data+toret[:-1] if toret[-1] == '&' else data
+    if isinstance(data, str) and continius is None:
+        if '?' in data:
+            link, args = data.split('?',1)
+            args_dict = {}
+            for i in args.split('&'):
+                key, value = i.split('=',1)
+                for i in range(0,256):
+                    value = value.replace(f'%{bytes([i]).hex()}',chr(i)).replace(f'%{bytes([i]).hex().upper()}',chr(i))
+                value = value.encode('latin-1')
+                try: value = value.decode(encoding=encoding)
+                except: pass
+                if isinstance(value,str):
+                    if value.lower() == 'true':
+                        value = True
+                    elif value.lower() == 'false':
+                        value = False
+                    elif value.isdigit():
+                        value = int(value)
+                    elif value.replace('.', '').isdigit():
+                        value = float(value)
+                args_dict[key] = value
+            return link, args_dict
+        else:
+            return data, {}

ghttp/server.py

@@ -0,0 +1,119 @@
+from .transfer_encoding import read as read_encoding
+import threading
+import socket
+
    if type(data)==str:
+        data = data.encode(encoding=encoding)
+    if type(status_code)==bytes:
+        status_code = status_code.decode('latin-1')
    close = False
    result = f"HTTP/{ver} {status_code}\x0d\x0a" 
    for key, value in headers.items():
        if key.lower()=='connection' and value.lower() == 'close':
            close = True
        result += f"{key}: {value}\x0d\x0a"
+        if key.lower() == 'connection' and value.lower() == 'close':
+            close = True
+    if not without_con:
        if not "\nconnection: " in result.lower():
            result += f"Connection: close\x0d\x0a"
            close = True
    if not without_len:
        if not "\ncontent-length: " in result.lower():
            result += f"Content-Length: {len(data)}\x0d\x0a"
    result += "\x0d\x0a"
    data = result.encode() + data
    conn.sendall(data)
    if close:
        conn.close()
+
    try:
        data = conn.recv(65500)
        while b'\r\n\r\n' not in data:
            chunk = conn.recv(65500)
            if chunk == b'':
                break
            data += chunk
    except: data = b''
    if not data == b'':
        data_split = data.find(b'\r\n\r\n')
        header, dta = data[:data_split], data[data_split+4:]
        headers = {}
        h = header.split(b'\r\n')
        if not require_ver:
            question = h[0][:h[0].rfind(b' HTTP')].split(b' ',1)
            question.append(None)
        else:
            question = h[0].split(b' ',1)
            question = question[0], *question[1].rsplit(b' ',1)
        for i in h[1:]:
            key, value = i.split(b':',1)
            key = key.decode(errors='replace')
            value = value.lstrip(b' ').decode(errors='replace')
            headers[key.lower()] = int(value) if value.isdigit() else value
+        if 'transfer-encoding' in headers:
+            dta = read_encoding(s,dta,headers['transfer-encoding'])
+        elif 'content-length' in headers:
            toread = headers['content-length']
            toread = int(toread) - len(dta)
            while toread > 0:
                chunk = conn.recv(toread if toread < 65500 else 65500)
+                dta += chunk
+                toread -= len(chunk)
        if len(question) == 3:
            if not binary_question:
                question = question[0].decode(), question[1].decode(), question[2].decode()
        else:
            raise ValueError(f"Question is strange.. {question}")
        return question, dta, headers
    else:
        return [None, None, None], None, {}
+
+def send_raw(conn, data):
+    if type(data)==bytes:
+        conn.sendall(data)
+    else:
+        raise ValueError("data must be bytes!")
+
+def read_chunk(conn):
+    try:
+        chunk_size_hex = b''
+        while True:
+            char = conn.recv(1)
+            if not char:
+                return None
+            if char == b'\n':
+                break
+            chunk_size_hex += char
+        if chunk_size_hex.endswith(b'\r'):
+            chunk_size_hex = chunk_size_hex[:-1]
+        try:
+            chunk_size = int(chunk_size_hex, 16)
+        except ValueError:
+            return None
+        if chunk_size == 0:
+            conn.recv(2)
+            return (b'', 0)
+        data = b''
+        while len(data) < chunk_size:
+            remaining = chunk_size - len(data)
+            chunk = conn.recv(min(remaining, 8192))
+            if not chunk:
+                return None
+            data += chunk
+        conn.recv(2)
+        return data, chunk_size
+    except Exception:
+        return None, None
+
+def read_raw(conn, data=None):
+    try: return conn.recv(data)
+    except: return None
+
+def close(conn):
+    try: conn.close()
+    except: pass
+
+def send_chunk(conn, data):
+    if type(data)==bytes:
+        conn.sendall(hex(len(data))[2:].encode() + b'\r\n' + data + b'\r\n')
+    else:
+        raise ValueError("data must be bytes!")
+
+class tserver():
+    def __init__(self, HOST='127.0.0.1', PORT=80, VER='1.1', precon=None, preaddr=None):
+        if precon == None:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.bind((HOST, PORT))
+            s.listen()
+            s.settimeout(5.0)
+            self.s = s
+        else:
+            self.s = None
+            self.conn = precon
+            self.addr = preaddr
+        self.ver = VER
+    def accept(self, get_raw=False):
+        if self.s == None:
+            raise ValueError("While using precon, not allowed method accept!")
+        else:
+            conn, addr = self.s.accept()
+            conn.settimeout(5.0)
+            self.conn, self.addr = conn, addr
+            if not get_raw:
+                return addr
+            else:
+                return conn, addr
+    def send(self, data, headers={}, status_code="200 OK", without_len=False, without_con=False):
+        send(self.conn, self.ver, data, headers, status_code, without_len, without_con)
+    def read(self, binary_question=False, require_ver=True):
+        return read(self.conn, binary_question, require_ver)
+    def send_raw(self, data):
+        send_raw(self.conn, data)
+    def send_chunk(self, data):
+        send_chunk(self.conn, data)
+    def read_chunk(self):
+        return read_chunk(self.conn)
+    def read_raw(self, count=None):
+        return read_raw(self.conn, count)
+    def close(self):
+        close(self.conn)
+
+def server(WRAPPER, HOST='127.0.0.1', PORT=80, VER='1.1', CUSTOM_SOCK=None, ARGS=()):
+    serv = tserver(HOST, PORT, VER)
+    if CUSTOM_SOCK is not None:
+        try: serv.close()
+        except: pass
+        serv.s = CUSTOM_SOCK
+    while True:
+        serv.s.settimeout(None)
+        conn, addr = serv.accept(get_raw=True)
+        s = tserver(HOST, PORT, VER, precon=conn, preaddr=addr)
+        t = threading.Thread(target=WRAPPER, daemon=True, args=(s,addr,*ARGS))
+        t.start()

ghttp/simple_client.py

@@ -0,0 +1,196 @@
+from .parsearg import parsearg
+from .client import client
+import json as json_mod
+import socket
+import ssl
+
+class _clresponse:
+    def __init__(self,data,code,text,headers):
+        self.text = data.decode(encoding='latin-1')
+        self.binary = data
+        self.status = code
+        self.text_status = text
+        self.headers = headers
+    def json(self):
+        return json.loads(self.text)
+
+def _send_with_retry(s, method, path, headers, payload, ip, port, getsock, max_retries=2):
+    for attempt in range(max_retries):
+        try:
+            s.send(method, path, headers=headers, without_len=True, data=payload)
+            return s
+        except Exception:
+            if attempt == max_retries - 1:
+                raise ValueError('Timeout')
+            s.close()
+            if getsock:
+                s = client()
+                s.connect(ip, port)
+            else:
+                s = client()
+                s.connect(ip, port)
+    return s
+
+def _receive_with_retry(s, ip, port, getsock, max_retries=2):
+    for attempt in range(max_retries):
+        try:
+            answer, data, headers = s.read()
+            return answer, data, headers
+        except Exception:
+            if attempt == max_retries - 1:
+                raise ValueError('Timeout')
+            s.close()
+            if getsock:
+                s = client()
+                s.connect(ip, port)
+            else:
+                s = client()
+                s.connect(ip, port)
+    return None, None, None
+
+def parseurl(url):
+    https = False
+    if 'https://' in url:
+        https = True
+    address = url.replace('http://', '').replace('https://', '')
+    address = address.split('/', 1)
+    addr, path = address[0], '/' if len(address) == 1 else '/' + address[1]
+    ip, port = addr.split(':', 1) if len(addr.split(':', 1)) == 2 else (addr, 80 if not https else 443)
+    port = int(port)
+    return ip, port, https, path
+
+def _get(url, data, json, headers, params, method, sock=None, close=True, getsock=False, usehost=True):
+    ip, port, https, path = parseurl(url)
+    if data is not None:
+        payload = data
+    elif json is not None:
+        payload = json_mod.dumps(json).encode()
+    else:
+        payload = b''
+    dfheaders = {}
+    if usehost:
+        dfheaders['Host'] = ip
+    if not payload == b'':
+        dfheaders['Content-Length'] = str(len(payload))
+    dfheaders.update(headers)
+    if sock is None:
+        s = client()
+        if https:
+            context = ssl.create_default_context()
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            ssl_sock = context.wrap_socket(sock, server_hostname=ip)
+            s.connect(ip, port, ssl_sock)
+        else:
+            s.connect(ip, port)
+    else:
+        s = sock
+    s = _send_with_retry(s, method, path, dfheaders, payload, ip, port, getsock)
+    answer, data, headers = _receive_with_retry(s, ip, port, getsock)
+    if data is None:
+        s.close()
+        s = client()
+        s.connect(ip, port)
+        s = _send_with_retry(s, method, path, dfheaders, payload, ip, port, getsock)
+        answer, data, headers = _receive_with_retry(s, ip, port, getsock)
+        if data is None:
+            raise ValueError('Timeout')
+    status = answer[1].split(' ', 1)
+    status_code = int(status[0])
+    status_text = status[1] if len(status) == 2 else None
+    if close:
+        s.close()
+    response = _clresponse(data, status_code, status_text, headers)
+    return (s, response) if getsock else response
+
+def get(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'GET', usehost=usehost)
+
+def post(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'POST', usehost=usehost)
+
+def delete(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'DELETE', usehost=usehost)
+
+def put(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'PUT', usehost=usehost)
+
+def head(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'HEAD', usehost=usehost)
+
+def connect(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'CONNECT', usehost=usehost)
+
+def options(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'OPTIONS', usehost=usehost)
+
+def trace(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'TRACE', usehost=usehost)
+
+def patch(url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+    return _get(url,data,json,headers,params,'PATCH', usehost=usehost)
+
+class Session:
+    def __init__(self):
+        self.s = None
+        self.url = None
+
+    def reload(self):
+        self.close()
+        self.s = None
+        self.url = None
+
+    def close(self):
+        try: self.s.close()
+        except: pass
+
+    def check_url(self, url):
+        ip, port, https, path = parseurl(url)
+        _url = f'{ip}:{port}'
+        if not _url == self.url:
+            self.url = _url
+            self.reload()
+
+    def get(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'GET',self.s,False,True,usehost)
+        return answer
+
+    def post(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'POST',self.s,False,True,usehost)
+        return answer
+
+    def delete(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'DELETE',self.s,False,True,usehost)
+        return answer
+
+    def put(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'PUT',self.s,False,True,usehost)
+        return answer
+
+    def head(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'HEAD',self.s,False,True,usehost)
+        return answer
+
+    def connect(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'CONNECT',self.s,False,True,usehost)
+        return answer
+
+    def options(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'OPTIONS',self.s,False,True,usehost)
+        return answer
+
+    def trace(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'TRACE',self.s,False,True,usehost)
+        return answer
+
+    def patch(self,url='localhost:80', data=None, json=None, headers={}, params={}, usehost=True):
+        self.check_url(url)
+        self.s, answer = _get(url,data,json,headers,params,'PATCH',self.s,False,True,usehost)
+        return answer

ghttp/simple_server.py

@@ -0,0 +1,85 @@
+from .parsearg import parsearg
+from .server import server
+import subprocess
+import json
+import ssl
+import os
+
+def serve(IP='localhost',PORT=80,PATH='./',silent=False,keep_alive=False,SSL=False,ssl_cert='cert.pem', ssl_key='key.pem'):
+    if SSL:
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        context.load_cert_chain(ssl_cert, ssl_key)
+    if PATH.endswith('/'):
+        PATH = PATH[:-1]
+    def wrapper(cl,addr,SSL,context):
+        if SSL:
+            try: cl.conn = context.wrap_socket(cl.conn, server_side=True)
+            except: pass
+        cl.conn.settimeout(30.0)
+        while True:
+            try:
+                question, data, headers = cl.read()
+                if data == None:
+                    if not silent:
+                        print(f'[{':'.join([str(i) for i in addr])}]: Closed',flush=True)
+                    cl.close()
+                    break
+                if question[0] == 'GET':
+                    cur_dir, args = parsearg(question[1])
+                    while cur_dir.find('..') != -1:
+                        cur_dir = cur_dir.replace( '..', '.')
+                    directory = PATH+cur_dir
+                    if not directory.endswith('/') and os.path.exists(directory) and os.path.isdir(directory):
+                        directory += '/'
+                    hasindex = False
+                    if os.path.exists(directory) and os.path.isdir(directory):
+                        files = os.listdir(directory)
+                        for i in files:
+                            if i == 'index.html' or i == 'index.py':
+                                hasindex = True
+                    if hasindex:
+                        if os.path.exists(f'{directory}index.py'):
+                            try:
+                                output = subprocess.check_output([f'{os.path.abspath(directory)}/index.py', json.dumps(args)], shell=True, stderr=subprocess.DEVNULL)
+                                cl.send(output,headers={"Connection": "keep-alive" if keep_alive else "close"})
+                            except:
+                                cl.send(b'',status_code='500 Internal Server Error',headers={"Connection": "keep-alive" if keep_alive else "close"})
+                        elif os.path.exists(f'{directory}index.html'):
+                            with open(f'{directory}index.html','rb') as f:
+                                cl.send(f.read(),headers={"Content-Type": "text/html; charset=utf-8", "Connection": "keep-alive" if keep_alive else "close"})
+                        if not silent:
+                            print(f'[{':'.join([str(i) for i in addr])}]: 200 OK {cur_dir}',flush=True)
+                    elif os.path.exists(directory):
+                        if not silent:
+                            print(f'[{':'.join([str(i) for i in addr])}]: 200 OK {cur_dir}',flush=True)
+                        if os.path.isdir(directory):
+                            result = f'<h1>List of {cur_dir}</h1><a href="..">↩</a><br>'
+                            for i in files:
+                                result += f'<a href="{directory}{i}">{i}</a><br>'
+                            cl.send(result.encode(),headers={"Content-Type": "text/html; charset=utf-8", "Connection": "keep-alive" if keep_alive else "close"})
+                        else:
+                            if directory.rsplit('.',1)[-1] == 'py':
+                                try:
+                                    output = subprocess.check_output([f'{os.path.abspath(directory)}', json.dumps(args)], shell=True, stderr=subprocess.DEVNULL)
+                                    cl.send(output,headers={"Connection": "keep-alive" if keep_alive else "close"})
+                                except:
+                                    cl.send(b'',status_code='500 Internal Server Error',headers={"Connection": "keep-alive" if keep_alive else "close"})
+                            else:
+                                with open(directory,'rb') as f:
+                                    cl.send(f.read(),{"Connection": "keep-alive" if keep_alive else "close"})
+                    else:
+                        if not silent:
+                            cl.send(b'',status_code='404 Not Found', headers={"Connection": "keep-alive" if keep_alive else "close"})
+                        print(f'[{':'.join([str(i) for i in addr])}]: 404 Not Found {cur_dir}',flush=True)
+                else:
+                    if not silent:
+                        cl.send(b'',status_code='400 Method Not Support', headers={"Connection": "keep-alive" if keep_alive else "close"})
+                    print(f'[{':'.join([str(i) for i in addr])}]: 400 Method Not Support',flush=True)
+            except:
+                if not silent:
+                    print(f'[{':'.join([str(i) for i in addr])}]: Error',flush=True)
+                cl.close()
+                break
+    if not silent:
+        print(f"Runned server at {IP}:{PORT}",flush=True)
+    server(wrapper,IP,PORT,ARGS=(SSL,context if SSL else None))

ghttp/transfer_encoding.py

@@ -0,0 +1,26 @@
+def _read_chunked(data, full_data, s):
+    header_end = data.find(b'\r\n')
+    if header_end == -1:
+        return data, full_data, False
+    header = data[:header_end]
+    try: toread = int(header.decode(), 16)
+    except: pass
+    if toread == 0:
+        return b'', full_data, True
+    rest = data[header_end + 2:]
+    while len(rest) < toread + 2:
+        rest += s.recv(min(65500, toread + 2 - len(rest)))
+    full_data += rest[:toread]
+    return rest[toread + 2:], full_data, False
+
+def read(s, data=b'', encoding='chunked'):
+    if encoding == 'chunked':
+        full_data = b''
+        while True:
+            header_end = data.find(b'\r\n')
+            if header_end != -1:
+                data, full_data, done = _read_chunked(data, full_data, s)
+                if done:
+                    return full_data
+            else:
+                data += s.recv(65500)

ghttp_tool-0.0.1.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: ghttp-tool
+Version: 0.0.1
+Summary: Multifunctional HTTP Lib
+Author-email: GPGStudio <gpgstudio.original@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/GPGSTUDIO/GHTTP
+Project-URL: Repository, https://github.com/GPGSTUDIO/GHTTP
+Project-URL: Bug Reports, https://github.com/GPGSTUDIO/GHTTP/issues
+Keywords: HTTP,TCP,Ethernet,Internet,Lan,Wan,
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# **Multifunction HTTP lib!**!
+
+Installing:
+```python
+pip install ghttp
+```
+
+See examples in https://www.gpgstudio.ru/pypi/ghttp/examples
+
+In latest version:
+> Created

ghttp_tool-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+ghttp/__init__.py,sha256=jY2T6M4ThweV6kFF0qjAuqHRGFUrZMhS1RcieVxli4U,619
+ghttp/client.py,sha256=L64nw63zKk-n5mKhfR_EeYVVh_mmFJ7PiS0ON8C1dLk,4584
+ghttp/parsearg.py,sha256=vU1d2gkBu87asrpclvTQmLzse3fY7ZACwiNnAeLJ7fM,1892
+ghttp/server.py,sha256=xXgFx5l-PVHXRXNKmAHhBqktr6MZM6u4IzeWEEcYF1o,6202
+ghttp/simple_client.py,sha256=MAyw7YC8PSGWhlJxeb1Sw3wnCG4odbw-_vkEJsdfubo,7794
+ghttp/simple_server.py,sha256=MbndQlobpUBbbC3ZP4P8_-OASs5DrICB9ZFnNUPHXmk,5129
+ghttp/transfer_encoding.py,sha256=uQrYaAMUkrS84uI7DlCtnAf4sPq_8bQAIwbc2eruEoM,900
+ghttp_tool-0.0.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ghttp_tool-0.0.1.dist-info/METADATA,sha256=g1HOmApis7R-pFQKfbsanD63RuPG7kxJ-r3nvAfLTxY,1210
+ghttp_tool-0.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+ghttp_tool-0.0.1.dist-info/top_level.txt,sha256=WAMhcBd3d2OyGry1vK6PI28CY45g-p5Xg6GaR27LXP0,6
+ghttp_tool-0.0.1.dist-info/RECORD,,

ghttp_tool-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ghttp_tool-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ghttp