requrst 0.5.0__py3-none-any.whl

requrst/__init__.py

@@ -0,0 +1,17 @@
+from .core import (
+    get,
+    post,
+    Session,
+    Response,
+    RequestContext,
+    register_before_request,
+    extract_html_text,
+    send_email,
+    DEFAULT_VERIFY,
+    DEFAULT_TIMEOUT,
+    DEFAULT_RETRY,
+    DEFAULT_MAX_REDIRECTS
+)
+
+__version__ = "0.5.0"
+

requrst/core.py

@@ -0,0 +1,303 @@
+import socket
+import ssl
+import json
+import re
+from urllib.parse import urlparse, urlencode
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Connection": "close"
+}
+DEFAULT_TIMEOUT = 10
+DEFAULT_RETRY = 1
+DEFAULT_MAX_REDIRECTS = 3
+DEFAULT_VERIFY = True
+
+class RequestContext:
+    def __init__(self, url: str, method: str, headers: dict, timeout: int):
+        self.url = url
+        self.method = method
+        self.headers = headers
+        self.timeout = timeout
+
+class Response:
+    def __init__(self, status_code: int, headers: dict, content: bytes):
+        self.status_code = status_code
+        self.headers = headers
+        self.content = content
+        self.encoding = self._auto_detect_encoding()
+
+    @property
+    def text(self):
+        return self.content.decode(self.encoding, errors="ignore")
+
+    def _auto_detect_encoding(self):
+        content_type = self.headers.get("content-type", "")
+        if "charset=" in content_type:
+            charset = content_type.split("charset=")[1].split(";")[0].strip().lower()
+            return charset
+        try:
+            self.content.decode("utf-8")
+            return "utf-8"
+        except UnicodeDecodeError:
+            return "gbk"
+
+    def json(self):
+        return json.loads(self.text)
+
+    def text_only(self):
+        text = re.sub(r"<script.*?</script>", "", self.text, flags=re.S | re.I)
+        text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
+        text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
+        text = re.sub(r"<.*?>", "", text)
+        text = re.sub(r"\s+", " ", text).strip()
+        return text
+
+before_request_hooks = []
+
+def register_before_request(func):
+    before_request_hooks.append(func)
+
+def _run_before_intercept(ctx: RequestContext):
+    for hook in before_request_hooks:
+        hook(ctx)
+
+def _parse_chunked_body(data: bytes) -> bytes:
+    result = b""
+    offset = 0
+    while True:
+        crlf_pos = data.find(b"\r\n", offset)
+        if crlf_pos == -1:
+            break
+        chunk_size_hex = data[offset:crlf_pos].decode("ascii").strip()
+        chunk_size = int(chunk_size_hex, 16)
+        offset = crlf_pos + 2
+        if chunk_size == 0:
+            break
+        result += data[offset:offset+chunk_size]
+        offset += chunk_size + 2
+    return result
+
+def _socket_request(
+    host, path, port, scheme, method, headers, body=b"",
+    timeout=10, verify=DEFAULT_VERIFY, retry=1, max_redirects=3
+):
+    for attempt in range(retry + 1):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(timeout)
+        try:
+            if scheme == "https":
+                context = ssl.create_default_context() if verify else ssl._create_unverified_context()
+                sock = context.wrap_socket(sock, server_hostname=host)
+
+            sock.connect((host, port))
+
+            req_lines = [f"{method} {path} HTTP/1.1", f"Host: {host}"]
+            for k, v in headers.items():
+                req_lines.append(f"{k}: {v}")
+            if body:
+                req_lines.append(f"Content-Length: {len(body)}")
+            req_lines.append("")
+
+            req_data = "\r\n".join(req_lines).encode("utf-8") + body
+            sock.sendall(req_data)
+
+            resp_data = b""
+            while True:
+                chunk = sock.recv(4096)
+                if not chunk:
+                    break
+                resp_data += chunk
+            sock.close()
+
+            header_end = resp_data.find(b"\r\n\r\n")
+            if header_end == -1:
+                raise Exception("Invalid HTTP response")
+            header_part = resp_data[:header_end].decode("utf-8", errors="ignore")
+            body_part = resp_data[header_end+4:]
+
+            first_line = header_part.splitlines()[0]
+            status_code = int(first_line.split()[1])
+
+            resp_headers = {}
+            for line in header_part.splitlines()[1:]:
+                if ": " in line:
+                    k, v = line.split(": ", 1)
+                    resp_headers[k.strip().lower()] = v.strip()
+
+            if resp_headers.get("transfer-encoding", "").lower() == "chunked":
+                body_part = _parse_chunked_body(body_part)
+
+            if status_code in (301, 302) and max_redirects > 0:
+                location = resp_headers.get("location", "")
+                if not location:
+                    break
+
+                new_method = "GET"
+                new_body = b""
+
+                redirect_url = urlparse(location)
+                if not redirect_url.netloc:
+                    redirect_url = urlparse(f"{scheme}://{host}{location}")
+                hp = redirect_url.netloc.split(":")
+                rh = hp[0]
+                rp = int(hp[1]) if len(hp) > 1 else (443 if redirect_url.scheme == "https" else 80)
+                return _socket_request(
+                    rh,
+                    redirect_url.path or "/",
+                    rp,
+                    redirect_url.scheme,
+                    new_method, headers, new_body,
+                    timeout, verify, retry, max_redirects-1
+                )
+
+            return Response(status_code, resp_headers, body_part)
+
+        except (socket.timeout, ConnectionError, ssl.SSLError) as e:
+            sock.close()
+            if attempt == retry:
+                return Response(0, {}, f"Request Failed: {str(e)}".encode("utf-8"))
+            continue
+        except Exception as e:
+            sock.close()
+            return Response(0, {}, f"Request Error: {str(e)}".encode("utf-8"))
+
+class Session:
+    def __init__(self):
+        self.cookies = {}
+        self.headers = DEFAULT_HEADERS.copy()
+        self.timeout = DEFAULT_TIMEOUT
+        self.retry = DEFAULT_RETRY
+        self.max_redirects = DEFAULT_MAX_REDIRECTS
+        self.verify = DEFAULT_VERIFY
+
+    def _update_cookies(self, resp_headers):
+        set_cookie = resp_headers.get("set-cookie", "")
+        if not set_cookie:
+            return
+        for cookie in set_cookie.split(", "):
+            if "=" in cookie:
+                key_val = cookie.split(";")[0]
+                if "=" in key_val:
+                    k, v = key_val.split("=", 1)
+                    self.cookies[k.strip()] = v.strip()
+
+    def _build_cookie_header(self):
+        return "; ".join([f"{k}={v}" for k, v in self.cookies.items()]) if self.cookies else ""
+
+    def get(self, url: str, params: dict = None, headers: dict = None, **kwargs) -> Response:
+        if params:
+            query = urlencode(params)
+            url += f"&{query}" if "?" in url else f"?{query}"
+
+        req_headers = self.headers.copy()
+        if headers:
+            req_headers.update(headers)
+        cookie_header = self._build_cookie_header()
+        if cookie_header:
+            req_headers["Cookie"] = cookie_header
+
+        ctx = RequestContext(url, "GET", req_headers, kwargs.get("timeout", self.timeout))
+        _run_before_intercept(ctx)
+
+        parsed = urlparse(ctx.url)
+        host_port = parsed.netloc.split(":")
+        host = host_port[0]
+        port = int(host_port[1]) if len(host_port) > 1 else (443 if parsed.scheme == "https" else 80)
+        path = parsed.path if parsed.path else "/"
+        if parsed.query:
+            path += "?" + parsed.query
+        scheme = parsed.scheme
+
+        resp = _socket_request(
+            host, path, port, scheme, "GET", ctx.headers, b"",
+            timeout=kwargs.get("timeout", self.timeout),
+            verify=kwargs.get("verify", self.verify),
+            retry=kwargs.get("retry", self.retry),
+            max_redirects=kwargs.get("max_redirects", self.max_redirects)
+        )
+        self._update_cookies(resp.headers)
+        return resp
+
+    def post(self, url: str, data: dict = None, json_data: dict = None, headers: dict = None, **kwargs) -> Response:
+        req_headers = self.headers.copy()
+        if headers:
+            req_headers.update(headers)
+        cookie_header = self._build_cookie_header()
+        if cookie_header:
+            req_headers["Cookie"] = cookie_header
+
+        body = b""
+        if json_data:
+            req_headers["Content-Type"] = "application/json; charset=utf-8"
+            body = json.dumps(json_data).encode("utf-8")
+        elif data:
+            req_headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
+            body = urlencode(data).encode("utf-8")
+
+        ctx = RequestContext(url, "POST", req_headers, kwargs.get("timeout", self.timeout))
+        _run_before_intercept(ctx)
+
+        parsed = urlparse(ctx.url)
+        host_port = parsed.netloc.split(":")
+        host = host_port[0]
+        port = int(host_port[1]) if len(host_port) > 1 else (443 if parsed.scheme == "https" else 80)
+        path = parsed.path if parsed.path else "/"
+        if parsed.query:
+            path += "?" + parsed.query
+        scheme = parsed.scheme
+
+        resp = _socket_request(
+            host, path, port, scheme, "POST", ctx.headers, body,
+            timeout=kwargs.get("timeout", self.timeout),
+            verify=kwargs.get("verify", self.verify),
+            retry=kwargs.get("retry", self.retry),
+            max_redirects=kwargs.get("max_redirects", self.max_redirects)
+        )
+        self._update_cookies(resp.headers)
+        return resp
+
+def get(url: str, params: dict = None, headers: dict = None, **kwargs) -> Response:
+    return Session().get(url, params, headers,** kwargs)
+
+def post(url: str, data: dict = None, json_data: dict = None, headers: dict = None, **kwargs) -> Response:
+    return Session().post(url, data, json_data, headers, **kwargs)
+
+def extract_html_text(html: str) -> str:
+    text = re.sub(r"<script.*?</script>", "", html, flags=S | re.I)
+    text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
+    text = re.sub(r"<.*?>", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+def send_email(
+    smtp_server: str,
+    smtp_port: int,
+    sender_email: str,
+    sender_pwd: str,
+    to_email: str,
+    subject: str,
+    content: str
+):
+    msg = MIMEMultipart()
+    msg["From"] = sender_email
+    msg["To"] = to_email
+    msg["Subject"] = subject
+    msg.attach(MIMEText(content, "plain", "utf-8"))
+
+    try:
+        if smtp_port == 465:
+            server = smtplib.SMTP_SSL(smtp_server, smtp_port)
+        else:
+            server = smtplib.SMTP(smtp_server, smtp_port)
+            server.starttls()
+        server.login(sender_email, sender_pwd)
+        server.sendmail(sender_email, to_email, msg.as_string())
+        server.quit()
+        return True, "邮件发送成功"
+    except Exception as e:
+        return False, f"发送失败: {str(e)}"

requrst-0.5.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: requrst
+Version: 0.5.0
+Summary: 纯Python Socket手写HTTP/HTTPS客户端，零第三方依赖，第二方自研请求库
+Home-page: 
+Author: 
+Author-email: 
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# pure-socket-http
+纯原生Socket手写HTTP/HTTPS协议栈，零依赖
+
+特性：
+- 零第三方依赖
+- 自动301/302重定向
+- 分块传输解析
+- 自动编码探测防乱码
+- Session自动Cookie保持
+- 请求拦截器
+- 自带网页文本提取
+- 内置SMTP邮件发送

requrst-0.5.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+requrst/__init__.py,sha256=pjIor-6IdFPQ8d9Tbe1VOx2X_n1adSaNbBTG5cU_RE8,266
+requrst/core.py,sha256=pqcoi_IBr3yVoDx6t7G48PTkAKOedh68qG3Zcbi52jY,11135
+requrst-0.5.0.dist-info/licenses/LICENSE,sha256=tQ-0w6byZoWSN8dbgiUAlwlXAacv5McP5Q16RR8cB4w,1064
+requrst-0.5.0.dist-info/METADATA,sha256=LzC_g9gAtgCRVt6RY5cOcujfQsVEQ2WQglrbedyrTrA,865
+requrst-0.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+requrst-0.5.0.dist-info/top_level.txt,sha256=X010-22ipGcj_Z2XyZEQFs-zXbb-neqx23Pg4BjWHZc,8
+requrst-0.5.0.dist-info/RECORD,,

requrst-0.5.0.dist-info/WHEEL

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

requrst-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shiroko
+
+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.

requrst-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+requrst