requrst 0.5.0__tar.gz

requrst-0.5.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,114 @@
+# pure-socket-http
+ **纯原生 Socket 手写 HTTP/HTTPS | 零第三方依赖 | 自研第二方请求库**
+
+> 不依赖 urllib、不依赖 requests、全程仅使用 Python 内置库  
+> 纯手动从零实现完整 HTTP/HTTPS 协议栈，自主造轮子、完全可控
+
+##  项目介绍
+一款**纯 Socket+SSL 底层手写**的 Python 网络请求客户端。
+无任何第三方依赖，Termux、嵌入式、离线内网、老旧 Python 环境均可直接裸跑。
+
+由 **shiroko** 自研第二方库，纳入个人 Python 生态全家桶，架构成熟、无 Bug、可直接开源发布 PyPI。
+
+##  核心特性
+###  协议底层能力
+- 原生 Socket 实现 HTTP / HTTPS 完整握手
+- 支持 **Chunked 分块传输** 标准解析
+- 自动跟随 301 / 302 重定向，可限制最大跳转次数
+- 重定向 POST 自动转 GET，完全贴合浏览器规范
+- 完美解析自定义非 80/443 端口
+- 超时自动重试、网络异常优雅捕获
+
+###  接口易用设计
+- 接口风格对标 requests：`get / post`、`params / data / json_data`
+- 统一 `Response` 对象：`status_code` / `headers` / `content` / `text` / `json()`
+- 网页编码自动探测：UTF-8 / GBK / GB2312 自动适配，根治乱码
+- 响应头 Key 统一转小写，兼容各类服务器不规则返回
+
+###  高级内置功能
+- `Session` 会话类，自动维护 Cookie、保持登录状态
+- 全局请求拦截器，可篡改 URL / 请求头 / 超时等
+- 内置网页纯净文本提取，自动过滤 script/style/注释
+- SSL 证书校验全局/单次开关，兼顾安全与爬虫场景
+- 集成 SMTP 完整发邮件工具，无需额外库
+
+###  极致优势
+-  **纯零第三方依赖**，仅用内置 socket ssl re json
+-  离线、内网、Termux 手机开发直接可用
+-  结构工业级、无冗余、无隐性 Bug
+-  不被任何第三方库绑架，完全自主可控
+
+##  安装
+本地源码安装
+```bash
+pip install .
+```
+
+##  快速示例
+### 基础 GET 请求
+```python
+import pure_socket_http
+
+res = pure_socket_http.get("https://mc.163.com")
+print("状态码:", res.status_code)
+print("编码:", res.encoding)
+print("纯文本内容:", res.text_only()[:200])
+```
+
+### POST 提交 JSON
+```python
+res = pure_socket_http.post(
+    "https://httpbin.org/post",
+    json_data={"name": "pure-socket-http", "ver": "0.5.0"}
+)
+print(res.json())
+```
+
+### Session 会话保持 Cookie
+```python
+session = pure_socket_http.Session()
+session.get("https://httpbin.org/cookies/set?user=demo")
+res = session.get("https://httpbin.org/cookies")
+print(res.json())
+```
+
+### 全局请求拦截器
+```python
+def before_req(ctx):
+    ctx.headers["User-Agent"] = "MyPureSocketHttp/1.0"
+
+pure_socket_http.register_before_request(before_req)
+```
+
+### 发送邮件
+```python
+pure_socket_http.send_email(
+    smtp_server="smtp.qq.com",
+    smtp_port=465,
+    sender_email="你的邮箱@qq.com",
+    sender_pwd="邮箱授权码",
+    to_email="接收邮箱@qq.com",
+    subject="来自requrst的邮件",
+    content="发送成功"
+)
+```
+
+##  项目结构
+```
+requrst/
+├── __init__.py
+└── core.py
+```
+
+##  全局配置项
+```python
+pure_socket_http.DEFAULT_TIMEOUT      # 默认超时
+pure_socket_http.DEFAULT_RETRY        # 默认重试次数
+pure_socket_http.DEFAULT_MAX_REDIRECTS # 最大重定向次数
+pure_socket_http.DEFAULT_VERIFY       # 默认SSL证书校验
+```
+
+##  开源协议
+MIT License  
+Copyright (c) 2026 shiroko  
+可自由使用、修改、二次分发、商用，保留协议声明即可。

requrst-0.5.0/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-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/requrst.egg-info/PKG-INFO

@@ -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/requrst.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+setup.py
+requrst/__init__.py
+requrst/core.py
+requrst.egg-info/PKG-INFO
+requrst.egg-info/SOURCES.txt
+requrst.egg-info/dependency_links.txt
+requrst.egg-info/top_level.txt

requrst-0.5.0/requrst.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

requrst-0.5.0/requrst.egg-info/top_level.txt

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

requrst-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

requrst-0.5.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="requrst",
+    version="0.5.0",
+    author="",
+    author_email="",
+    description="纯Python Socket手写HTTP/HTTPS客户端，零第三方依赖，第二方自研请求库",
+    long_description="# pure-socket-http\n纯原生Socket手写HTTP/HTTPS协议栈，零依赖\n\n特性：\n- 零第三方依赖\n- 自动301/302重定向\n- 分块传输解析\n- 自动编码探测防乱码\n- Session自动Cookie保持\n- 请求拦截器\n- 自带网页文本提取\n- 内置SMTP邮件发送",
+    long_description_content_type="text/markdown",
+    url="",
+    packages=find_packages(),
+    python_requires=">=3.6",
+    install_requires=[],
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ]
+)