flask-ks3 0.1.0__py3-none-any.whl

flask_ks3/__init__.py

@@ -0,0 +1,209 @@
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Dict, Sequence, Tuple
+from urllib.parse import quote
+
+import requests
+from flask import Flask
+
+from . import utils
+from .ks3_auth import add_auth_header
+from .types import CompletedPart
+
+
+class FlaskKS3:
+    def __init__(self, app=None):
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: Flask):
+        self.access_key = app.config["KS3_ACCESS_KEY"]
+        self.secret = app.config["KS3_SECRET"]
+        self.endpoint = app.config["KS3_ENDPOINT"]
+        self.bucket_name = app.config["KS3_BUCKET"]
+
+        self.client = KS3Client(
+            access_key=self.access_key,
+            secret=self.secret,
+            bucket_name=self.bucket_name,
+            endpoint=self.endpoint,
+        )
+
+    def put_object(self, object_key: str, local_path: Path) -> requests.Response:
+        return self.client.put_object(object_key, local_path)
+
+    def head_object(self, object_key: str) -> requests.Response:
+        return self.client.head_object(object_key)
+
+    def initiate_multipart_upload(self, object_key: str) -> str:
+        return self.client.initiate_multipart_upload(object_key)
+
+    def abort_multipart_upload(self, object_key: str, upload_id: str) -> str:
+        return self.client.abort_multipart_upload(object_key, upload_id)
+
+    def list_multipart_uploads(self) -> str:
+        return self.client.list_multipart_uploads()
+
+    def list_parts(self, object_key: str, upload_id: str) -> str:
+        return self.client.list_parts(object_key, upload_id)
+
+    def upload_part(
+        self, object_key: str, upload_id: str, part_number: int, filepath: str | Path
+    ) -> str:
+        return self.client.upload_part(object_key, upload_id, part_number, filepath)
+
+    def complete_multipart_upload(
+        self, object_key: str, upload_id: str, parts: Sequence[CompletedPart]
+    ) -> requests.Response:
+        return self.client.complete_multipart_upload(object_key, upload_id, parts)
+
+
+class KS3Client:
+    def __init__(
+        self,
+        access_key: str,
+        secret: str,
+        bucket_name: str,
+        endpoint: str,
+    ):
+        self.access_key = access_key
+        self.secret = secret
+        self.bucket_name = bucket_name
+        self.endpoint = endpoint
+        self._base_url = f"https://{self.bucket_name}.{self.endpoint}"
+
+    def get_url_and_headers(
+        self,
+        method: str,
+        object_key: str,
+        query: str = "",
+        headers: Dict[str, str] | None = None,
+    ) -> Tuple[str, Dict[str, str]]:
+        if not all([self.access_key, self.secret, self.endpoint, self.bucket_name]):
+            raise RuntimeError("FlaskKS3 is not initialized; call init_app first")
+
+        headers = dict(headers) if headers else {}
+        add_auth_header(
+            self.access_key,
+            self.secret,
+            headers,
+            method,
+            self.bucket_name,
+            object_key,
+            query,
+        )
+        quoted_key = quote(object_key, safe="/")
+        url = f"{self._base_url}/{quoted_key}"
+        if query:
+            url = f"{url}?{query}"
+        return url, headers
+
+    def put_object(self, object_key: str, local_path: Path) -> requests.Response:
+        url, headers = self.get_url_and_headers("PUT", object_key)
+        with local_path.open("rb") as f:
+            response = requests.put(url, headers=headers, data=f, timeout=3600)
+        if response.status_code == 200:
+            print("普通上传成功")
+        else:
+            print(f"上传失败: {response.status_code}, {response.text}")
+        return response
+
+    def head_object(self, object_key: str) -> requests.Response:
+        url, headers = self.get_url_and_headers("HEAD", object_key)
+        response = requests.request("HEAD", url, headers=headers, timeout=60)
+        if response.status_code == 200:
+            print(f"xyyebesr 文件已存在 {object_key}")
+        elif response.status_code == 404:
+            print(f"b1s6sstz 文件不存在 {object_key}")
+        else:
+            print(
+                f"20z4ojsw 文件状态码错误 {object_key}, {response.status_code}, {response.text}"
+            )
+        return response
+
+    # 下面的方法是分快上传相关的方法 https://docs.ksyun.com/documents/42466?type=3
+    def initiate_multipart_upload(self, object_key: str) -> str:
+        """获取分块上传的upload_id"""
+        url, headers = self.get_url_and_headers("POST", object_key, query="uploads")
+        response = requests.post(url, headers=headers)
+        if response.status_code == 200:
+            xml_root = ET.fromstring(response.text)
+            ns = {"s3": "http://s3.amazonaws.com/doc/2006-03-01/"}
+            upload_id = xml_root.findtext("s3:UploadId", namespaces=ns)
+            print(f"UploadId: {upload_id}")
+            if upload_id:
+                return upload_id
+            raise RuntimeError("未从响应中解析到 UploadId")
+
+        raise RuntimeError(
+            f"分块初始化上传失败 initiate_upload: {response.status_code}, {response.text}"
+        )
+
+    def abort_multipart_upload(self, object_key: str, upload_id: str) -> None:
+        url, headers = self.get_url_and_headers(
+            "DELETE", object_key, query=f"uploadId={upload_id}"
+        )
+        response = requests.delete(url, headers=headers)
+        assert (
+            response.status_code == 204
+        ), f"中止分块上传失败 abort_upload: {response.status_code}, {response.text}"
+        return response
+
+    def list_multipart_uploads(self) -> requests.Response:
+        url, headers = self.get_url_and_headers("GET", "", query="uploads")
+        response = requests.get(url, headers=headers)
+        assert (
+            response.status_code == 200
+        ), f"列出分块上传失败 list_uploads: {response.status_code}, {response.text}"
+        return response
+
+    def list_parts(self, object_key: str, upload_id: str) -> requests.Response:
+        url, headers = self.get_url_and_headers(
+            "GET", object_key, query=f"uploadId={upload_id}"
+        )
+        response = requests.get(url, headers=headers)
+        assert (
+            response.status_code == 200
+        ), f"列出分块失败 list_parts: {response.status_code}, {response.text}"
+        return response
+
+    def upload_part(
+        self, object_key: str, upload_id: str, part_number: int, filepath: str | Path
+    ) -> str:
+        """上传单个分片并返回 ETag。"""
+        query = f"partNumber={part_number}&uploadId={upload_id}"
+        url, headers = self.get_url_and_headers("PUT", object_key, query=query)
+        with Path(filepath).open("rb") as f:
+            response = requests.put(url, headers=headers, data=f, timeout=1800)
+            print(
+                f"上传分片 {part_number} , 状态码: {response.status_code}, text: {response.text}"
+            )
+        if response.status_code != 200:
+            raise RuntimeError(
+                f"分片 {part_number} 上传失败: {response.status_code}, {response.text}"
+            )
+
+        etag = response.headers.get("ETag")
+        if not etag:
+            raise RuntimeError(f"分片 {part_number} 上传成功但缺少 ETag")
+        clean_etag = etag.strip('"')
+        print(f"分片 {part_number} 上传成功，ETag: {clean_etag}")
+        return clean_etag
+
+    def complete_multipart_upload(
+        self, object_key: str, upload_id: str, parts: Sequence[CompletedPart]
+    ) -> requests.Response:
+        xml_body = utils.generate_complete_multipart_xml(parts)
+        query = f"uploadId={upload_id}"
+        base_headers = {"Content-Type": "application/xml"}
+        url, headers = self.get_url_and_headers(
+            "POST", object_key, query=query, headers=base_headers
+        )
+        print(f"url: {url}, headers: {headers}")
+        print(f"xml_body: {xml_body}")
+
+        response = requests.post(url, headers=headers, data=xml_body)
+        if response.status_code != 200:
+            raise RuntimeError(f"合并失败: {response.status_code}, {response.text}")
+        print("所有分片合并成功，上传完成！")
+        return response

flask_ks3/ks3_auth.py

@@ -0,0 +1,165 @@
+import base64
+import hmac
+import urllib.parse as parse
+from email.utils import formatdate
+from hashlib import sha1 as sha
+
+qsa_of_interest = {
+    "acl",
+    "cors",
+    "defaultObjectAcl",
+    "location",
+    "logging",
+    "partNumber",
+    "policy",
+    "requestPayment",
+    "torrent",
+    "versioning",
+    "versionId",
+    "versions",
+    "website",
+    "uploads",
+    "uploadId",
+    "response-content-type",
+    "response-content-language",
+    "response-expires",
+    "response-cache-control",
+    "response-content-disposition",
+    "response-content-encoding",
+    "delete",
+    "lifecycle",
+    "tagging",
+    "restore",
+    "notification",
+    "thumbnail",
+    "queryadp",
+    "adp",
+    "asyntask",
+    "querytask",
+    "domain",
+    "storageClass",
+    "websiteConfig",
+    "compose",
+    "quota",
+    "policy",
+    "crr",
+    "fetch",
+    "append",
+    "position",
+    "mirror",
+    "retention",
+    "recycle",
+    "recover",
+    "clear",
+    "inventory",
+    "id",
+}
+
+
+def url_encode(key):
+    if not key:
+        return ""
+    return parse.quote(str(key), safe="/~")
+
+
+def encode_params(query_args):
+    if not query_args:
+        return ""
+    if isinstance(query_args, dict):
+        map_args = {k: v for k, v in query_args.items() if k}
+    else:
+        map_args = {}
+        for param in filter(None, query_args.split("&")):
+            k, _, v = param.partition("=")
+            if k:
+                map_args[k] = v
+    buf_list = []
+    for k in sorted(map_args):
+        if k not in qsa_of_interest:
+            continue
+        v = map_args[k]
+        if v is None or v == "":
+            buf_list.append(k)
+        else:
+            buf_list.append(f"{k}={v}")
+    return "&".join(buf_list)
+
+
+def canonical_resource(bucket, key, query_args):
+    buf = f"/{bucket}/" if bucket else "/"
+    if key:
+        buf += url_encode(key)
+
+    buf = buf.replace("//", "/%2F")
+    params = encode_params(query_args)
+    return f"{buf}?{params}" if params else buf
+
+
+def canonical_headers(headers):
+    if not headers:
+        return ""
+    interesting_headers = {
+        key.lower(): value
+        for key, value in headers.items()
+        if key.lower().startswith("x-kss-")
+    }
+    return "\n".join(
+        f"{header_key}:{interesting_headers[header_key]}"
+        for header_key in sorted(interesting_headers)
+    )
+
+
+def canonical_string(
+    method, bucket="", key="", query_args=None, headers=None, expires=None
+):
+    headers = headers or {}
+    query_args = query_args or ""
+
+    can_resource = canonical_resource(bucket, key, query_args)
+    can_headers = canonical_headers(headers)
+    content_md5 = ""
+    content_type = ""
+    date = ""
+    for header_key, val in headers.items():
+        lk = header_key.lower()
+        if not val:
+            continue
+        if lk == "content-md5":
+            content_md5 = val
+        elif lk == "content-type":
+            content_type = val
+        elif lk == "date":
+            date = val
+    if expires:
+        date = str(expires)
+    sign_list = [method, content_md5, content_type, date]
+    if can_headers:
+        sign_list.append(can_headers)
+    sign_list.append(can_resource)
+    sign_str = "\n".join(sign_list)
+    print(f"sign_list: {sign_list}")
+    return sign_str
+
+
+def encode(secret_access_key, str_to_encode, urlencode=False):
+    secret_access_key = secret_access_key.encode("utf-8")
+    str_to_encode = str_to_encode.encode("utf-8")
+    digest = hmac.new(secret_access_key, str_to_encode, sha).digest()
+    b64_hmac = base64.b64encode(digest).decode("utf-8").strip()
+    if urlencode:
+        return parse.quote_plus(b64_hmac)
+    return b64_hmac
+
+
+def add_auth_header(
+    access_key_id, secret_access_key, headers, method, bucket, key, query_args
+):
+    if not access_key_id:
+        return
+    if "Date" not in headers:
+        headers["Date"] = formatdate(usegmt=True)
+
+    c_string = canonical_string(method, bucket, key, query_args, headers)
+    headers["Authorization"] = (
+        f"KSS {access_key_id}:{encode(secret_access_key, c_string)}"
+    )

flask_ks3/types.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class CompletedPart(TypedDict):
+    PartNumber: int
+    ETag: str

flask_ks3/utils.py

@@ -0,0 +1,18 @@
+import xml.etree.ElementTree as ET
+from typing import Sequence
+
+from .types import CompletedPart
+
+
+def generate_complete_multipart_xml(parts: Sequence[CompletedPart]) -> str:
+    if not parts:
+        raise ValueError("parts 不能为空")
+
+    root = ET.Element("CompleteMultipartUpload")
+    for part in sorted(parts, key=lambda p: p["PartNumber"]):
+        part_number = part["PartNumber"]
+        etag = part["ETag"]
+        part_el = ET.SubElement(root, "Part")
+        ET.SubElement(part_el, "PartNumber").text = str(part_number)
+        ET.SubElement(part_el, "ETag").text = etag
+    return ET.tostring(root, encoding="utf-8", method="xml").decode("utf-8")

flask_ks3-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: flask-ks3
+Version: 0.1.0
+Summary: 
+License-File: LICENSE
+Author: codeif
+Author-email: me@codeif.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: flask (>=3.1.2,<4.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# flask-ks3

flask_ks3-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+flask_ks3/__init__.py,sha256=Ov82ov0H4YohLH7DrLYi_jTz7M2cfZajUNCBqqAdPrQ,8186
+flask_ks3/ks3_auth.py,sha256=JzFJmknsmrtfDGA1Um2ZbOCfeTcL4S2elvCCjhKNG1Q,4049
+flask_ks3/types.py,sha256=UPhppmNm6TDxaj_s8uAcm-YFiGjrpzSBF8yRFABph7Y,97
+flask_ks3/utils.py,sha256=i7u-orqy5NluwgFxoEEao0SWXf29XiSP6kSTR9Lr844,664
+flask_ks3-0.1.0.dist-info/METADATA,sha256=u9O0cAYE_9ciNFPFp6dUIkKmPy_AjT7V-js68LzME8M,486
+flask_ks3-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+flask_ks3-0.1.0.dist-info/licenses/LICENSE,sha256=NORyCM3QNwH4bVA3amh_iC2aOodBZvHnjuiLsQSZQv0,1493
+flask_ks3-0.1.0.dist-info/RECORD,,

flask_ks3-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

flask_ks3-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, codeif
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.