http-content-parser 0.0.25__tar.gz → 0.0.27__tar.gz

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: http_content_parser
-Version: 0.0.25
+Version: 0.0.27
 Summary: parse http's payload and response
 Author-email: leo <suleiabc@gmail.com>
 License-File: LICENSE

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "http_content_parser"
-version = "0.0.25"
+version = "0.0.27"
 authors = [{ name = "leo", email = "suleiabc@gmail.com" }]
 description = "parse http's payload and response"
 readme = "README.md"

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/src/http_content_parser/api_parser.py

@@ -5,66 +5,39 @@ import re
 from http_content_parser.curl_parser import CurlParser
 from http_content_parser.openapi_parser import OpenApiParser
 from http_content_parser.postman_parser import parse_postman
-from http_content_parser.req_data import ReqData
 from http_content_parser.swagger2_parser import Swagger2Parser
 
 
 class ApiModelParser:
-    def get_api_model_for_curl(self, curl_file, curl_filter=None) -> list[ReqData]:
-        # convert curl
-        payload_list = self.convert_curl_data_to_model(
-            curl_file_path=curl_file, url_filter=curl_filter
-        )
-        # handle duplicate key
-        new_payload_list = self.__handle_duplicate_api_label(payload_list)
-        return new_payload_list
 
     def get_api_list_for_curl(self, curl_file, curl_filter=None) -> list[dict]:
         # convert curl
-        payload_list = self.convert_curl_data_to_list(
+        payload_list = self.convert_curl_to_list(
             curl_file_path=curl_file, url_filter=curl_filter
         )
         # handle duplicate key
         new_payload_list = self.__handle_duplicate_api_label_for_dict(payload_list)
         return new_payload_list
 
-    def get_api_model_for_postman(self, json_dict: dict) -> list[ReqData]:
-        payload_list = self.convert_postman_to_model(postman_dict=json_dict)
-        # handle duplicate key
-        new_payload_list = self.__handle_duplicate_api_label(payload_list)
-        return new_payload_list
-
     def get_api_list_for_postman(self, json_dict: dict) -> list[dict]:
         payload_list = self.convert_postman_to_list(postman_dict=json_dict)
         # handle duplicate key
         new_payload_list = self.__handle_duplicate_api_label_for_dict(payload_list)
         return new_payload_list
 
-    def get_api_model_for_swagger(self, json_dict: dict) -> list[ReqData]:
-        payload_list = self.convert_swagger_to_model(swagger2_dict=json_dict)
-        # handle duplicate key
-        new_payload_list = self.__handle_duplicate_api_label(payload_list)
-        return new_payload_list
-
     def get_api_list_for_swagger(self, json_dict: dict) -> list[dict]:
         payload_list = self.convert_swagger_to_list(swagger2_dict=json_dict)
         # handle duplicate key
         new_payload_list = self.__handle_duplicate_api_label_for_dict(payload_list)
         return new_payload_list
 
-    def get_api_model_for_openapi(self, json_dict: dict) -> list[ReqData]:
-        payload_list = self.convert_openapi_to_model(openapi_dict=json_dict)
-        # handle duplicate key
-        new_payload_list = self.__handle_duplicate_api_label(payload_list)
-        return new_payload_list
-
     def get_api_list_for_openapi(self, json_dict: dict) -> list[dict]:
         payload_list = self.convert_openapi_to_list(openapi_dict=json_dict)
         # handle duplicate key
         new_payload_list = self.__handle_duplicate_api_label_for_dict(payload_list)
         return new_payload_list
 
-    def convert_curl_data_to_list(
+    def convert_curl_to_list(
         self, curl_file_path: str, url_filter=None
     ) -> list[dict]:
         curl_parser = CurlParser()
@@ -94,34 +67,6 @@ class ApiModelParser:
                 payload_list.append(req_data)
         return payload_list
 
-    def convert_curl_data_to_model(
-        self, curl_file_path: str, url_filter=None
-    ) -> list[ReqData]:
-        curl_parser = CurlParser()
-        payload_list = []
-        with open(curl_file_path, "rt") as f:
-            lines = f.readlines()
-            line_num_array = curl_parser.get_curl_line_num_scope(lines=lines)
-            for r in line_num_array:
-                res_dict = curl_parser.split_curl_to_struct(
-                    lines, r[0], r[1], url_filter
-                )
-                req_model = ReqData(dd=res_dict)
-                url_content = curl_parser.parse_url(req_model.original_url)
-                req_model.temp_api_label = (
-                    self.__replace_api_label_chars(url_content["path"][1:])
-                    + "_"
-                    + req_model.method
-                )
-                req_model.header = json.dumps(req_model.header)
-                if url_content["query_params"]:
-                    req_model.query_param = json.dumps(url_content["query_params"])
-                else:
-                    req_model.query_param = {}
-                req_model.path = url_content["path"][1:]
-                payload_list.append(req_model)
-        return payload_list
-
     def convert_postman_to_list(self, postman_dict: dict) -> list[dict]:
         api_infos = parse_postman(postman_dict) or []
         payload_list = []
@@ -147,52 +92,6 @@ class ApiModelParser:
             payload_list.append(req_data)
         return payload_list
 
-    def convert_postman_to_model(self, postman_dict: dict) -> list[ReqData]:
-        api_infos = parse_postman(postman_dict)
-        payload_list = []
-        for api_info in api_infos:
-            req_data = ReqData()
-            req_data.path = api_info["path"]
-            req_data.header = json.dumps(api_info["header"])
-            req_data.body = api_info["body"]
-            req_data.query_param = json.dumps(api_info["query_param"])
-            req_data.original_url = api_info["url"]
-            req_data.method = api_info["method"].lower()
-            req_data.temp_api_label = (
-                self.__handle_http_path(api_info["path"].split("/"), "_")
-                .replace("{", "")
-                .replace("}", "")
-                + "_"
-                + api_info["method"].lower()
-            )
-            payload_list.append(req_data)
-        return payload_list
-
-    def convert_swagger_to_model(self, swagger2_dict: dict) -> list[ReqData]:
-        swagger_parser = Swagger2Parser(swagger2_dict)
-        api_dict = swagger_parser.get_swagger_api_info()
-        if not api_dict:
-            print("check your swagger json")
-            return []
-        payload_list = []
-        for path, path_info in api_dict.items():
-            req_data = ReqData()
-            req_data.path = self.__handle_http_path(path.split("/")[:-1], "/")
-            req_data.temp_api_label = (
-                self.__handle_http_path(path.split("/"), "_")
-                .replace("{", "")
-                .replace("}", "")
-            )
-            req_data.method = path.split("/")[-1]
-            req_data.query_param = json.dumps(path_info["query_param"])
-            req_data.path_param = json.dumps(path_info["path_param"])
-            req_data.response = json.dumps(path_info.get("response", {}))
-            # swagger中body第一层和第二层key重复,只取第二层后的数据
-            for _, v in path_info["body_param"].items():
-                req_data.body = json.dumps(v)
-            payload_list.append(req_data)
-        return payload_list
-
     def convert_swagger_to_list(self, swagger2_dict: dict) -> list[dict]:
         swagger_parser = Swagger2Parser(swagger2_dict)
         api_dict = swagger_parser.get_swagger_api_info()
@@ -219,29 +118,6 @@ class ApiModelParser:
             payload_list.append(req_data)
         return payload_list
 
-    def convert_openapi_to_model(self, openapi_dict: dict) -> list[ReqData]:
-        if not openapi_dict:
-            return []
-        payload_list = []
-        parser = OpenApiParser(openapi_dict)
-        api_dict = parser.get_open_api_info()
-        if not api_dict:
-            return []
-        for path, path_info in api_dict.items():
-            parts = path.split("/")
-            req = ReqData()
-            req.path = self.__handle_http_path(parts[:-1], "/")
-            req.temp_api_label = (
-                self.__handle_http_path(parts, "_").replace("{", "").replace("}", "")
-            )
-            req.method = parts[-1]
-            req.query_param = json.dumps(path_info.get("query_param", {}))
-            req.path_param = json.dumps(path_info.get("path_param", {}))
-            req.response = json.dumps(path_info.get("response", {}))
-            req.body = json.dumps(path_info.get("body_param", {}))
-            payload_list.append(req)
-        return payload_list
-
     def convert_openapi_to_list(self, openapi_dict: dict) -> list[dict]:
         if not openapi_dict:
             return []
@@ -284,20 +160,6 @@ class ApiModelParser:
         new_string = re.sub(pattern, replacement, string)
         return new_string
 
-    def __handle_duplicate_api_label(
-        self, payload_list: list[ReqData]
-    ) -> list[ReqData]:
-        key_filter = {}
-        new_payload_list = copy.deepcopy(payload_list)
-        for payload, p_copy in zip(payload_list, new_payload_list):
-            k = payload.temp_api_label
-            if k in key_filter.keys():
-                p_copy.temp_api_label = k + "_" + str(key_filter[k])
-                key_filter[k] += 1
-            else:
-                key_filter[k] = 2
-        return new_payload_list
-
     def __handle_duplicate_api_label_for_dict(
         self, payload_list: list[dict]
     ) -> list[dict]:

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/src/http_content_parser/curl_parser.py

@@ -176,13 +176,23 @@ class CurlParser(object):
             # Body 解析
             # ---------------------------
             elif "--data" in line or "--data-raw" in line:
-                # 去掉行尾的转义符
-                clean = line.replace("\\\n", "").strip()
-
-                # 提取单引号内容
-                m = re.search(r"'(.*)'$", clean)
-                if m:
-                    req_data["body"] = m.group(1)
+                # 去掉转义符和多余的空白
+                clean = line.replace("\\\n", "").replace("\\", "").strip()
+                
+                # 提取单引号内容 - 更健壮的方式
+                # 找到第一个单引号的位置
+                first_quote = clean.find("'")
+                if first_quote != -1:
+                    # 找到最后一个单引号的位置
+                    last_quote = clean.rfind("'")
+                    if last_quote > first_quote:
+                        # 提取中间的内容，并清理所有换行和多余空白
+                        body_content = clean[first_quote + 1 : last_quote]
+                        # 移除所有换行符并压缩空白
+                        body_content = re.sub(r"\s+", " ", body_content).strip()
+                        req_data["body"] = body_content
+                    else:
+                        req_data["body"] = ""
                 else:
                     # 兼容无引号情况
                     req_data["body"] = clean.split("--data")[-1].strip()

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/src/http_content_parser/param_util.py

@@ -5,29 +5,6 @@ class ParamUtil(object):
     def __init__(self) -> None:
         self._param_list = []
 
-    @staticmethod
-    def merge_api_params(swagger_dict: dict, api_dict: dict) -> dict:
-        result = {}
-        swagger_fail_dict = []
-        for k, v in swagger_dict.items():
-            if v["path_param"] or v["query_param"]:
-                if api_dict.get(k):
-                    temp_v = v
-                    temp_v["body_type"] = v["body"]
-                    temp_v["body"] = api_dict[k]["body"]
-                    temp_v["original_url"] = api_dict[k]["original_url"]
-                    temp_v["query_param"] = api_dict[k]["query_param"]
-                    result[k] = temp_v
-                else:
-                    swagger_fail_dict.append(k.replace("_", "/"))
-            else:
-                if api_dict.get(k):
-                    result[k] = api_dict[k]
-                else:
-                    swagger_fail_dict.append(k.replace("_", "/"))
-                    # result[k] = v
-        return result, swagger_fail_dict
-
     @staticmethod
     def split_swagger_param_and_type(param, nontype=False):
         sp = SwaggerParam()
@@ -97,7 +74,8 @@ class ParamUtil(object):
         if isinstance(value, dict):
             return "{}"
         if isinstance(value, list):
-            if len(value) == 1 and not isinstance(value[0], dict):
+            # 如果list有多个元素，且不是dict，那么直接返回原始值
+            if len(value) >= 1 and not isinstance(value[0], dict):
                 return value
             else:
                 return "[]"
@@ -170,7 +148,8 @@ class SwaggerParam(object):
         if isinstance(value, dict):
             return "{}"
         if isinstance(value, list):
-            if len(value) == 1 and not isinstance(value[0], dict):
+            # 如果list有多个元素，且不是dict，那么直接返回原始值
+            if len(value) >= 1 and not isinstance(value[0], dict):
                 return value
             else:
                 return "[]"

http_content_parser-0.0.27/tests/test_fix.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+
+from src.http_content_parser.curl_parser import CurlParser
+
+
+def test_multiline_json_body():
+    # 测试用户提供的多行 JSON 数据
+    test_file = '/Users/bytedance/Documents/vs_workspace/myself/HttpParser/tests/tmp'
+    
+    with open(test_file, 'r') as f:
+        lines = f.readlines()
+    
+    parser = CurlParser()
+    scopes = parser.get_curl_line_num_scope(lines)
+    
+    print(f"Found {len(scopes)} curl command(s)")
+    
+    for s, e in scopes:
+        # 测试旧方法
+        print("\n--- Testing split_curl_to_struct_old ---")
+        result_old = parser.split_curl_to_struct_old(lines, s, e)
+        print(f"Method: {result_old.get('method')}")
+        print(f"URL: {result_old.get('original_url')}")
+        body_old = result_old.get('body', '')
+        print(f"Body length: {len(body_old)}")
+        print(f"Body starts with: {body_old[:100]}...")
+        
+        # 测试新方法
+        print("\n--- Testing split_curl_to_struct ---")
+        result_new = parser.split_curl_to_struct(lines, s, e)
+        print(f"Method: {result_new.get('method')}")
+        print(f"URL: {result_new.get('original_url')}")
+        body_new = result_new.get('body', '')
+        print(f"Body length: {len(body_new)}")
+        print(f"Body starts with: {body_new[:100]}...")
+        
+        # 验证 body 是否完整
+        try:
+            import json
+            parsed_body = json.loads(body_new)
+            print("\n✅ Body parsed successfully as JSON!")
+            print(f"   - create count: {len(parsed_body.get('create', []))}")
+            print(f"   - update count: {len(parsed_body.get('update', []))}")
+            print(f"   - delete count: {len(parsed_body.get('delete', []))}")
+        except json.JSONDecodeError as e:
+            print(f"\n❌ Failed to parse body as JSON: {e}")
+
+
+if __name__ == '__main__':
+    test_multiline_json_body()

{http_content_parser-0.0.25 → http_content_parser-0.0.27}/tests/test_param_util.py

@@ -1,4 +1,3 @@
-import json
 from http_content_parser.param_util import ParamUtil
 
 
@@ -128,3 +127,19 @@ def test_param_util4():
         {"['name']": "[]"},
     ]
     assert result == expected_result
+
+
+def test_param_util_5():
+    s = {
+        "vmid": ["3690976212158729", "2"],
+        "type": ["1", "2", "3"],
+        "pn": [],
+    }
+    result = ParamUtil.split_swagger_param_and_type(s, nontype=False)
+    print(result)
+    expected_result = [
+        {"['vmid']": ["3690976212158729", "2"]},
+        {"['type']": ["1", "2", "3"]},
+        {"['pn']": '[]'},
+    ]
+    assert result == expected_result

http_content_parser-0.0.25/src/http_content_parser/req_data.py

@@ -1,116 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-"""
-__author__ = leo
-"""
-
-
-class ReqData(object):
-
-    def __init__(self, dd=None):
-        if dd and isinstance(dd, dict):
-            self.__path = dd.get('path', '')
-            self.__method = dd.get('method', '')
-            self.__body = dd.get('body', {})
-            self.__header = dd.get('header', {})
-            self.__query_param = dd.get('query_param', {})
-            self.__path_param = dd.get('path_param', {})
-            self.__original_url = dd.get('original_url', '')
-            self.__temp_api_label = dd.get('temp_api_label', '')
-            self.__host = ''
-            self.__response = dd.get('response', {})
-        else:
-            self.__host = ''
-            self.__path = ''
-            self.__method = ''
-            self.__body = {}
-            self.__header = {}
-            self.__query_param = {}
-            self.__path_param = {}
-            self.__original_url = ''
-            self.__temp_api_label = ''
-            self.__response = {}
-
-    @property
-    def temp_api_label(self):
-        return self.__temp_api_label
-
-    @temp_api_label.setter
-    def temp_api_label(self, value):
-        self.__temp_api_label = value
-
-    @property
-    def url(self):
-        return self.__host + self.__path
-
-    @property
-    def original_url(self):
-        return self.__original_url
-
-    @original_url.setter
-    def original_url(self, value):
-        self.__original_url = value
-
-    @property
-    def method(self):
-        return self.__method
-
-    @method.setter
-    def method(self, value):
-        self.__method = value
-
-    @property
-    def body(self):
-        return self.__body
-
-    @body.setter
-    def body(self, value):
-        self.__body = value
-
-    @property
-    def header(self):
-        return self.__header
-
-    @header.setter
-    def header(self, value):
-        self.__header = value
-
-    @property
-    def host(self):
-        return self.__host
-
-    @host.setter
-    def host(self, value):
-        self.__host = value
-
-    @property
-    def path(self):
-        return self.__path
-
-    @path.setter
-    def path(self, value):
-        self.__path = value
-
-    @property
-    def query_param(self):
-        return self.__query_param
-
-    @query_param.setter
-    def query_param(self, value):
-        self.__query_param = value
-
-    @property
-    def path_param(self):
-        return self.__path_param
-
-    @path_param.setter
-    def path_param(self, value):
-        self.__path_param = value
-
-    @property
-    def response(self):
-        return self.__response
-
-    @response.setter
-    def response(self, value):
-        self.__response = value