http-content-parser 0.0.1__py3-none-any.whl

http_content_parser/curl_parser.py

@@ -0,0 +1,118 @@
+# -*- coding: UTF-8 -*-
+class CurlParser(object):
+    def split_url(self, url: str, split_char: str):
+        # TODO 考虑url中没有http字符的情况(只出现在Postman导出的curl)
+        url_params = {}
+        if '?' in url:
+            ss = url.split('?')
+            url = ss[0]
+            url_params = ss[1]
+            url_params = self.form_str_to_dict(url_params)
+        urls = url.split('/')
+        url_path = ''
+        for i in range(3, len(urls)):
+            url_path += urls[i] + split_char
+        return {'url_path': url_path, 'url_params': url_params}
+
+    def form_str_to_dict(self, form_data):
+        """将form表单参数转成dict类型"""
+        item_dict = {}
+        if '&' in form_data:
+            for item in form_data.split('&'):
+                line = item.split('=')
+                if len(line) == 2:
+                    item_dict[line[0]] = line[1]
+                if len(line) == 1:
+                    item_dict[line[0]] = ''
+        else:
+            if '=' in form_data:
+                line = form_data.split('=')
+                item_dict[line[0]] = line[1]
+        return item_dict
+
+    # 处理curl中data部分的数据,把多行转换成一行数据
+    def reduce_curl_data_part(self, lines, s, e):
+        new_lines = []
+        for i in range(s, e):
+            new_line = lines[i]
+            if '--data ' in lines[i]:
+                # 判断请求的body是否完整,根据''单引号是否是两个
+                char_count = lines[i].count('\'')
+                if char_count == 1:
+                    i += 1
+                    while i < e:
+                        new_line += lines[i]
+                        if lines[i].count('\'') == 1:
+                            break
+                        i += 1
+            new_lines.append(new_line)
+        return new_lines
+
+    def get_curl_line_num_scope(self, lines):
+        start_num = 0
+        num = 0
+        curl_num = 0
+        line_num_array = []
+        for line in lines:
+            # 拆分多个curl
+            if 'curl' in line:
+                curl_num += 1
+                if curl_num >= 2:
+                    line_num_array.append([start_num, num-1])
+                    curl_num = 1
+                start_num = num
+            num += 1
+            if num == len(lines):
+                line_num_array.append([start_num, num])
+        return line_num_array
+
+    def split_curl_to_struct(self, lines, s, e, curl_filter=None) -> dict:
+        req_data = {}
+        header = {}
+        reduced_lines = self.reduce_curl_data_part(lines=lines, s=s, e=e)
+        for i in range(0, len(reduced_lines)):
+            lines_i_str = str(reduced_lines[i])
+            line_i_list = lines_i_str.split(' ')
+            if 'curl' in lines_i_str:
+                if curl_filter:
+                    if curl_filter not in lines_i_str:
+                        # 如果curl_filter 不存在于当前Url中,则跳过本次循环
+                        continue
+                for line_sub in line_i_list:
+                    if line_sub.lower() in ['get', 'put', 'post', 'delete']:
+                        req_data['method'] = line_sub.lower().replace('\'', '')
+                    elif 'http' in line_sub:
+                        req_data['original_url'] = line_sub.replace('\'', '')
+                    # 兼容Postman中url没有http开头的情况
+                    elif '/' in line_sub:
+                        req_data['original_url'] = line_sub.replace('\'', '')
+            elif '-X ' in lines_i_str:
+                line_i_list = lines_i_str.split(' \'')
+                req_data['method'] = line_i_list[1].lower().replace(
+                    '\'', '').replace(' ', '').replace('\\\n', '')
+            elif '-H \'' in lines_i_str or '--header' in lines_i_str:
+                line_i_list = lines_i_str.split(' \'')
+                subs = str(line_i_list[1]).split(':')
+                if len(subs) > 1:
+                    # TODO 空格区分有用和无用，目前cookie的value中会有包含空格的情况, 不删除
+                    header[subs[0]] = subs[1].replace(
+                        '\'', '').replace('\\\n', '').replace(' ', '')
+                else:
+                    header[subs[0]] = ''
+            elif '--data-raw' in lines_i_str or '--data' in lines_i_str:
+                line_i_list = lines_i_str.replace(' $',' ').split(' \'') # TODO 有$符号,split会失败,这样解决会出现被错误替换的问题
+                if len(line_i_list) > 1:
+                    curl_data = line_i_list[1]
+                else:
+                    curl_data = line_i_list[0]
+                req_data['body'] = curl_data.replace(
+                    '\'', '').replace(' ', '').replace('\\\n', '').replace('\n', '')
+
+                if not req_data.get('method'):
+                    req_data['method'] = 'post'
+
+        req_data['header'] = header
+        if not req_data.get('method'):
+            req_data['method'] = 'get'
+            
+        return req_data

http_content_parser/generate_api_file.py

@@ -0,0 +1,122 @@
+# -*- coding: UTF-8 -*-
+import json
+import re
+from http_content_parser.curl_parser import CurlParser
+import yaml
+from http_content_parser.req_data import ReqData
+from http_content_parser.swagger2_parser import Swagger2Parser
+from http_content_parser.openapi_parser import OpenApiParser
+from http_content_parser.postman_parser import parse_postman
+
+
+class GenerateApiFile():
+
+    def __init__(self) -> None:
+        pass
+
+    def produce_api_yaml_for_postman(self, json_dict, yaml_file):
+        api_infos = parse_postman(json_dict)
+        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.convert_swagger2_path(
+                api_info['path'].split('/'), '_').replace('{', '').replace('}', '') + "_" + api_info['method'].lower()
+            self.write_api_content_to_yaml(yaml_file, req_data)
+
+    def produce_api_yaml_for_curl(self, curl_file, yaml_file, curl_filter=None):
+        curl_parser = CurlParser()
+        with open(curl_file, '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], curl_filter)
+                template = ReqData(dd=res_dict)
+                split_url = curl_parser.split_url(template.original_url, '_')
+                template.temp_api_label = self.replace_api_label_chars(
+                    split_url['url_path']) + template.method
+                template.header = json.dumps(template.header)
+                template.query_param = json.dumps(split_url['url_params'])
+                split_url_origin = curl_parser.split_url(
+                    template.original_url, '/')
+                template.path = split_url_origin['url_path'][:-1]
+                self.write_api_content_to_yaml(yaml_file, template)
+
+    def produce_api_yaml_for_swagger2(self, swagger2_dict, yaml_file):
+        swagger_parser = Swagger2Parser(swagger2_dict)
+        api_dict = swagger_parser.get_swagger_api_info()
+        if not api_dict:
+            print('check your swagger json')
+            return
+        for path, path_info in api_dict.items():
+            req_data = ReqData()
+            req_data.path = self.convert_swagger2_path(
+                path.split('/')[:-1], '/')
+            req_data.temp_api_label = self.convert_swagger2_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)
+            self.write_api_content_to_yaml(yaml_file, req_data)
+
+    def produce_api_yaml_for_openapi3(self, openapi_dict, yaml_file):
+        if not openapi_dict:
+            print('openapi dict is null')
+            return
+        parser = OpenApiParser(openapi_dict)
+        api_dict = parser.get_open_api_info()
+        if not api_dict:
+            print('check your swagger json')
+            return
+        for path, path_info in api_dict.items():
+            req_data = ReqData()
+            req_data.path = self.convert_swagger2_path(
+                path.split('/')[:-1], '/')
+            req_data.temp_api_label = self.convert_swagger2_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', {}))
+            req_data.body = json.dumps(path_info['body_param'])
+            self.write_api_content_to_yaml(yaml_file, req_data)
+
+    def convert_swagger2_path(self, path_list, split_char):
+        if not path_list:
+            return ''
+        url_path = ''
+        for u in path_list:
+            if u:
+                url_path += u + split_char
+        return url_path[:-1]
+
+    def replace_api_label_chars(self, string):
+        pattern = r'[+@?=.]'  # 定义要匹配的特殊字符模式
+        replacement = '_'  # 替换为的字符串
+
+        new_string = re.sub(pattern, replacement, string)
+        return new_string
+
+    def write_api_content_to_yaml(self, file, template: ReqData):
+        api_obj = {}
+        yaml_obj = {}
+        with open(file, 'at') as f:
+            api_obj['original_url'] = template.original_url
+            api_obj['path'] = template.path
+            api_obj['query_param'] = template.query_param
+            api_obj['path_param'] = template.path_param
+            api_obj['header'] = template.header
+            api_obj['body'] = template.body
+            api_obj['method'] = template.method
+            api_obj['response'] = template.response
+            yaml_obj[template.temp_api_label] = api_obj
+            yaml.dump(yaml_obj, f)

http_content_parser/openapi_parser.py

@@ -0,0 +1,159 @@
+
+class OpenApiParser(object):
+    def __init__(self, openapi_json_dict) -> None:
+        self.openapi_dict = openapi_json_dict
+        self.schema_ref_list = []
+
+    def parse_request_body(self, api_info):
+        body_param_dict = {}
+        api_content_type = ''
+        if api_info.get('requestBody'):
+            request_body = api_info['requestBody']
+            for content_type, schema in request_body['content'].items():
+                api_content_type = content_type
+                for k, v in schema['schema']['properties'].items():
+                    if v.get('items'):
+                        if v['items'].get('$ref'):
+                            schema_ref = v['items']['$ref'].split('/')[-1]
+                            body_param_dict[k] = self.parse_body_schema(
+                                schema_ref)
+                            self.schema_ref_list = []
+                        else:
+                            body_param_dict[k] = [
+                                v.get('type', 'unknown_type')]
+
+                    else:
+                        body_param_dict[k] = v.get('type', 'unknown_type')
+        return body_param_dict, api_content_type
+
+    def parse_parameters(self, params):
+        path_param_dict = {}
+        body_param_dict = {}
+        query_param_dict = {}
+        form_data_param_dict = {}
+        for param in params:
+            if isinstance(param, dict):
+                if param.get('in') == 'path':
+                    path_param_dict[param['name']] = param['schema']['type']
+                elif param.get('in') == 'query':
+                    query_param_dict[param['name']] = param['schema']['type']
+                elif param.get('in') == 'formData':
+                    form_data_param_dict[param['name']
+                                         ] = param['schema']['type']
+                else:
+                    print('error: parameters in type error')
+
+        return body_param_dict, path_param_dict, query_param_dict, form_data_param_dict
+
+    def parse_body_schema(self, param_schema_ref):
+        self.schema_ref_list.append(param_schema_ref)
+        schema_dict = {}
+        schema_info = self.openapi_dict['components']['schemas'].get(
+            param_schema_ref)
+        if schema_info:
+            properties = schema_info.get('properties')
+            if isinstance(properties, dict):
+                for param, param_type_dict in properties.items():
+                    if param_type_dict.get('$ref'):
+                        schema_ref_name = param_type_dict['$ref'].split(
+                            '/')[-1]
+                        if schema_ref_name not in self.schema_ref_list:
+                            self.schema_ref_list.append(schema_ref_name)
+                            sub_param_value = self.parse_body_schema(
+                                schema_ref_name)
+                            if param_type_dict.get('type') == 'array':
+                                schema_dict[param] = [sub_param_value]
+                            else:
+                                schema_dict[param] = sub_param_value
+                        else:
+                            if param_type_dict.get('type') == 'array':
+                                schema_dict[param] = [{}]
+                            else:
+                                schema_dict[param] = {}
+                    elif param_type_dict.get('items'):
+                        if param_type_dict['items'].get('$ref'):
+                            schema_item_ref_name = param_type_dict['items']['$ref'].split(
+                                '/')[-1]
+                            if schema_item_ref_name not in self.schema_ref_list:
+                                self.schema_ref_list.append(
+                                    schema_item_ref_name)
+                                sub_param_value = self.parse_body_schema(
+                                    schema_item_ref_name)
+                                schema_dict[param] = [sub_param_value]
+                            else:
+                                schema_dict[param] = [{}]
+                        else:
+                            schema_dict[param] = [param_type_dict['type']]
+                    else:
+                        if param_type_dict.get('type'):
+                            schema_dict[param] = param_type_dict['type']
+                        else:
+                            schema_dict[param] = param_type_dict
+        return schema_dict
+
+    def parse_response(self, res_dict):
+        res = {}
+        # openapi's schema position
+        content = res_dict['200']['content']
+        schema = {}
+        for _, c_v in content.items():
+            schema = c_v['schema']
+        if schema.get("$ref"):
+            schema_ref_name = schema['$ref'].split('/')[-1]
+            res = self.parse_body_schema(schema_ref_name)
+            self.schema_ref_list = []
+            return res
+        elif schema.get("items"):
+            schema_ref_name = schema['items']['$ref'].split('/')[-1]
+            # TODO array schema: [{}] or {} ?
+            res = self.parse_body_schema(schema_ref_name)
+            self.schema_ref_list = []
+            return res
+        else:
+            for _, v in schema.items():
+                if isinstance(v, list):
+                    for item_dict in v:
+                        if isinstance(item_dict, dict):
+                            for item_k, item_v in item_dict.items():
+                                if item_k == '$ref':
+                                    schema_ref_name = item_v.split('/')[-1]
+                                    res.update(
+                                        self.parse_body_schema(schema_ref_name))
+                                    self.schema_ref_list = []
+                                if item_k == 'properties':
+                                    for k2, v2 in item_v.items():
+                                        if v2.get('$ref'):
+                                            schema_ref_name = v2['$ref'].split(
+                                                '/')[-1]
+                                            res[k2] = self.parse_body_schema(
+                                                schema_ref_name)
+                                            self.schema_ref_list = []
+
+        return res
+
+    def get_open_api_info(self):
+        result = {}
+        base_path = self.openapi_dict['servers'][0]['url']
+        for path, api_infos in (self.openapi_dict['paths']).items():
+            for path_method, api_info in api_infos.items():
+                _path_param = {}
+                _query_param = {}
+                _form_param = {}
+                _body_param = {}
+                _api_response = {}
+                if api_info.get('parameters'):
+                    api_param = self.parse_parameters(api_info['parameters'])
+                    _path_param = api_param[1]
+                    _query_param = api_param[2]
+                    _form_param = api_param[3]
+                if api_info.get('requestBody'):
+                    body_result = self.parse_request_body(api_info)
+                    _body_param = body_result[0]
+                    # content_type = result[1]
+                if api_info.get('responses'):
+                    _api_response = self.parse_response(api_info['responses'])
+
+                result[f'{base_path}{path}/{path_method}'] = {'path_param': _path_param,
+                                                              'query_param': _query_param, 'form_param': _form_param, 'body_param': _body_param, 'response': _api_response}
+
+        return result

http_content_parser/postman_parser.py

@@ -0,0 +1,44 @@
+# -*- coding: UTF-8 -*-
+import json
+
+
+api_info_list = []
+
+
+def parse_postman(json_file):
+    # TODO 如果postman中有变量,则无法解析变量的值.
+    items = json_file.get('item')
+    if items:
+        for item in items:
+            if item.get('item'):
+                parse_postman(item)
+            else:
+                api_info = {}
+                if not item.get('request'):
+                    continue
+                postman_request = item['request']
+                api_info['method'] = postman_request['method']
+                api_info['header'] = {}
+                for hs in postman_request['header']:
+                    api_info['header'][hs['key']] = hs['value']
+                api_info['url'] = postman_request['url']['raw']
+                if not postman_request['url'].get('path'):
+                    continue
+                api_info['path'] = "/".join(postman_request['url']['path'])
+                api_info['query_param'] = {}
+                if postman_request['url'].get('query'):
+                    for qs in postman_request['url']['query']:
+                        api_info['query_param'][qs['key']] = qs['value']
+                api_info['body'] = {}
+                if postman_request.get('body'):
+                    temp = postman_request['body'][postman_request['body']['mode']]
+                    if isinstance(temp, str):
+                        # \\n 只会出现在value中,一般是用户自己定义的
+                        temp = temp.replace("\\n", "").replace("\n", "")
+                        if temp:
+                            # beautify json string
+                            temp = json.loads(temp)
+                            temp = json.dumps(temp)
+                    api_info['body'] = temp
+                api_info_list.append(api_info)
+    return api_info_list

http_content_parser/req_data.py

@@ -0,0 +1,116 @@
+# -*- coding: UTF-8 -*-
+
+"""
+__author__ = maxsulei
+"""
+
+
+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

http_content_parser/swagger2_parser.py

@@ -0,0 +1,130 @@
+# -*- coding: UTF-8 -*-
+class Swagger2Parser(object):
+    def __init__(self, swagger_json_dict) -> None:
+        self.swagger_dict = swagger_json_dict
+        self.schema_ref_list = []
+
+    def parse_parameters(self, params):
+        path_param_dict = {}
+        body_param_dict = {}
+        query_param_dict = {}
+        form_data_param_dict = {}
+        for param in params:
+            if isinstance(param, dict):
+                if param.get('in') == 'path':
+                    path_param_dict[param['name']] = param['type']
+                elif param.get('in') == 'body':
+                    if param.get('schema'):
+                        schema_ref = param['schema']['$ref'].split('/')[-1]
+                        body_param_dict[param['name']
+                                        ] = self.parse_body_schema(schema_ref)
+                        self.schema_ref_list = []
+                elif param.get('in') == 'query':
+                    query_param_dict[param['name']] = param['type']
+                elif param.get('in') == 'formData':
+                    form_data_param_dict[param['name']] = param['type']
+                else:
+                    print('error: parameters in type error')
+
+        return body_param_dict, path_param_dict, query_param_dict, form_data_param_dict
+
+    def parse_body_schema(self, param_schema_ref):
+        self.schema_ref_list.append(param_schema_ref)
+        schema_dict = {}
+        schema_info = self.swagger_dict['definitions'].get(param_schema_ref)
+        if schema_info:
+            properties = schema_info.get('properties')
+            if isinstance(properties, dict):
+                for param, param_type_dict in properties.items():
+                    if param_type_dict.get('$ref'):
+                        schema_ref_name = param_type_dict['$ref'].split(
+                            '/')[-1]
+                        # prevent infinite loop
+                        if schema_ref_name not in self.schema_ref_list:
+                            self.schema_ref_list.append(schema_ref_name)
+                            sub_param_value = self.parse_body_schema(
+                                schema_ref_name)
+                            if param_type_dict.get('type') == 'array':
+                                schema_dict[param] = [sub_param_value]
+                            else:
+                                schema_dict[param] = sub_param_value
+                        else:
+                            if param_type_dict.get('type') == 'array':
+                                schema_dict[param] = [{}]
+                            else:
+                                schema_dict[param] = {}
+                    elif param_type_dict.get('items'):
+                        if param_type_dict['items'].get('$ref'):
+                            schema_item_ref_name = param_type_dict['items']['$ref'].split(
+                                '/')[-1]
+                            if schema_item_ref_name not in self.schema_ref_list:
+                                self.schema_ref_list.append(
+                                    schema_item_ref_name)
+                                sub_param_value = self.parse_body_schema(
+                                    schema_item_ref_name)
+                                schema_dict[param] = [sub_param_value]
+                            else:
+                                schema_dict[param] = [{}]
+                        else:
+                            schema_dict[param] = [param_type_dict['type']]
+                    else:
+                        if param_type_dict.get('type'):
+                            schema_dict[param] = param_type_dict['type']
+                        else:
+                            schema_dict[param] = param_type_dict
+        return schema_dict
+
+    def parse_response(self, res_dict):
+        res = {}
+        if res_dict['200'].get('schema'):
+            schema = res_dict['200']['schema']
+            if schema.get("$ref"):
+                schema_ref_name = schema['$ref'].split('/')[-1]
+                res = self.parse_body_schema(schema_ref_name)
+                self.schema_ref_list = []
+                return res
+            elif schema.get("items"):
+                schema_ref_name = schema['items']['$ref'].split('/')[-1]
+                # TODO array schema: [{}] or {} ?
+                res = self.parse_body_schema(schema_ref_name)
+                self.schema_ref_list = []
+                return res
+            else:
+                for _, v in schema.items():
+                    if isinstance(v, list):
+                        for item_dict in v:
+                            if isinstance(item_dict, dict):
+                                for item_k, item_v in item_dict.items():
+                                    if item_k == '$ref':
+                                        schema_ref_name = item_v.split('/')[-1]
+                                        res.update(
+                                            self.parse_body_schema(schema_ref_name))
+                                        self.schema_ref_list = []
+                                    if item_k == 'properties':
+                                        for k2, v2 in item_v.items():
+                                            if v2.get('$ref'):
+                                                schema_ref_name = v2['$ref'].split(
+                                                    '/')[-1]
+                                                res[k2] = self.parse_body_schema(
+                                                    schema_ref_name)
+                                                self.schema_ref_list = []
+
+        else:
+            print('response dont have schema')
+        return res
+
+    def get_swagger_api_info(self):
+        result = {}
+        base_path = self.swagger_dict['basePath'].replace('/', '')
+        for path, api_infos in (self.swagger_dict['paths']).items():
+            for path_method, api_info in api_infos.items():
+                if api_info.get('parameters'):
+                    api_param = self.parse_parameters(api_info['parameters'])
+                    api_res = self.parse_response(api_info['responses'])
+                    result[f'{base_path}{path}/{path_method}'] = {'path_param': api_param[1],
+                                                                  'query_param': api_param[2], 'form_param': api_param[3], 'body_param': api_param[0], 'response': api_res}
+                else:
+                    result[f'{base_path}{path}/{path_method}'] = {'path_param': {},
+                                                                  'query_param': {}, 'form_param': {}, 'body_param': {}}
+
+        return result

http_content_parser-0.0.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: http_content_parser
+Version: 0.0.1
+Summary: parse http's payload and response
+Author-email: max su <suleiabc@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# HttpParser Package
+
+This is a http content parser package.

http_content_parser-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+http_content_parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+http_content_parser/curl_parser.py,sha256=cYid9nC5K9rgntkxm8tGUy3Xd8B2XZNUCw9-z7P6Oc8,5009
+http_content_parser/generate_api_file.py,sha256=PgHn70AxqFONkP6UYErI_kVvJcNiNHgk0niuaIkABzM,5551
+http_content_parser/openapi_parser.py,sha256=oL9PzYyecKhUC9am2XEdlqfRzgvMsKWP67aq8eDZWwY,7619
+http_content_parser/postman_parser.py,sha256=e2pYtfDoFSfMCbtlyeykcNb92-x-AnK3OZWgNShOpik,1833
+http_content_parser/req_data.py,sha256=OrumKhN3RmUEciXZw-pQZNOirmIefY9dLHMODNMG41I,2629
+http_content_parser/swagger2_parser.py,sha256=UuUmY4OdDE5KjdZqHkHhxXZJGU-M-ODNlF4fg8x2ev8,6695
+http_content_parser-0.0.1.dist-info/METADATA,sha256=p0a9bMrfMDKWXCbGL32hyi4NgRzqstF-S45hS9r5WQA,441
+http_content_parser-0.0.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+http_content_parser-0.0.1.dist-info/licenses/LICENSE,sha256=7EI8xVBu6h_7_JlVw-yPhhOZlpY9hP8wal7kHtqKT_E,1074
+http_content_parser-0.0.1.dist-info/RECORD,,

http_content_parser-0.0.1.dist-info/WHEEL

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

http_content_parser-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.