lesscode-tag 0.0.6__tar.gz → 0.0.7__tar.gz

{lesscode_tag-0.0.6 → lesscode_tag-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode_tag
-Version: 0.0.6
+Version: 0.0.7
 Summary: lesscode_tag是标签处理工具包
 Author: Chao.yy
 Author-email: yuyc@ishangqi.com

{lesscode_tag-0.0.6 → lesscode_tag-0.0.7}/lesscode_tag/business.py

@@ -1,4 +1,4 @@
-from lesscode_tag.es_util import es_condition_by_terms, es_condition_by_wildcard
+from lesscode_utils.es_utils import es_condition_by_terms, es_condition_by_wildcard
 
 
 def get_single_tag_condition(tag):
@@ -109,7 +109,6 @@ def format_param_tag(bool_should_more_list, especial_tag_list):
             if tag in ["规上企业"]:
                 es_condition_by_terms(bool_should_list, "tags.nonpublic_tag", [tag])
     bool_should_more_list.append(bool_should_list)
-    return bool_should_more_list
 
 
 def parse_special_tag_new(tags, tags_param_list=None):

lesscode_tag-0.0.7/lesscode_tag/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.7"

{lesscode_tag-0.0.6 → lesscode_tag-0.0.7}/lesscode_tag.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-tag
-Version: 0.0.6
+Version: 0.0.7
 Summary: lesscode_tag是标签处理工具包
 Author: Chao.yy
 Author-email: yuyc@ishangqi.com

{lesscode_tag-0.0.6 → lesscode_tag-0.0.7}/lesscode_tag.egg-info/SOURCES.txt

@@ -1,11 +1,10 @@
 README.md
 setup.py
 lesscode_tag/__init__.py
-lesscode_tag/aes.py
 lesscode_tag/business.py
-lesscode_tag/es_util.py
 lesscode_tag/version.py
 lesscode_tag.egg-info/PKG-INFO
 lesscode_tag.egg-info/SOURCES.txt
 lesscode_tag.egg-info/dependency_links.txt
+lesscode_tag.egg-info/requires.txt
 lesscode_tag.egg-info/top_level.txt

lesscode_tag-0.0.7/lesscode_tag.egg-info/requires.txt

@@ -0,0 +1 @@
+lesscode_utils>=0.0.1

{lesscode_tag-0.0.6 → lesscode_tag-0.0.7}/setup.py

@@ -24,6 +24,7 @@ setuptools.setup(
     platforms='python',
     install_requires=[
         # "pycryptodomex==3.17"
+        "lesscode_utils>=0.0.1"
     ]
 
 )
@@ -46,6 +47,6 @@ twine upload dist/*
 twine upload dist/* -u yuyc -p yu230225
 twine upload dist/* --repository-url https://pypi.chanyeos.com/ -u admin -p shangqi
 # 安装最新的版本测试
-pip install -U lesscode_charts -i https://pypi.org/simple
-pip install -U lesscode_charts -i https://pypi.chanyeos.com/simple
+pip install -U lesscode_tag -i https://pypi.org/simple
+pip install -U lesscode_tag -i https://pypi.chanyeos.com/simple
 """

lesscode_tag-0.0.6/lesscode_tag/aes.py

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-import base64
-import binascii
-import importlib
-
-
-class AES:
-    @staticmethod
-    def encrypt(key="haohaoxuexi", text=""):
-        """
-        :param key: 密钥
-        :param text: 需要被加密的数据
-        """
-        try:
-            _AES = importlib.import_module("Cryptodome.Cipher.AES")
-        except ImportError:
-            raise Exception(f"pycryptodomex is not exist,run:pip install pycryptodomex==3.17")
-        text = str(text)
-        aes = _AES.new(AES.add_to_16(key), _AES.MODE_ECB)
-        encrypt_aes = aes.encrypt(AES.add_to_16(text))
-        encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8')
-        return bytes.decode(binascii.b2a_hex(bytes(encrypted_text, encoding="utf8")))
-
-    @staticmethod
-    def decrypt(key="haohaoxuexi", text=""):
-        """
-        :param key: 密钥
-        :param text: 需要被加密的数据
-        """
-        try:
-            _AES = importlib.import_module("Cryptodome.Cipher.AES")
-        except ImportError:
-            raise Exception(f"pycryptodomex is not exist,run:pip install pycryptodomex==3.17")
-        text = bytes.decode(binascii.a2b_hex(bytes(text, encoding="utf8")))
-        # 密文
-        # 初始化加密器
-        aes = _AES.new(AES.add_to_16(key), _AES.MODE_ECB)
-        # 优先逆向解密base64成bytes
-        base64_decrypted = base64.decodebytes(text.encode(encoding='utf-8'))
-        # 执行解密密并转码返回str
-        decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '')
-        return decrypted_text
-
-    @staticmethod
-    def add_to_16(value):
-        """
-        :param value: 待处理的数据
-        """
-        while len(value) % 16 != 0:
-            value += '\0'
-        return str.encode(value)  # 返回bytes

lesscode_tag-0.0.6/lesscode_tag/es_util.py

@@ -1,302 +0,0 @@
-from lesscode_tag.aes import AES
-
-
-def format_company_id_en(value, route_key, key="haohaoxuexi"):
-    if route_key in ["core.patent", "core.patent_lite"]:
-        for data in value.get("tags", {}).get("proposer_type", []):
-            if data.get("code"):
-                data["code"] = AES.encrypt(key, data["code"])
-    elif route_key in ["core.research_institution"]:
-        for data in value.get("tags", {}).get("support_unit", []):
-            if data.get("id"):
-                data["id"] = AES.encrypt(key, data["id"])
-    elif route_key in ["core.investment"]:
-        for data in value.get("tags", {}).get("invest_company", []):
-            if data.get("company_id"):
-                data["company_id"] = AES.encrypt(key, data["company_id"])
-
-
-def format_es_param_result(r, param_list, is_need_decrypt, is_need_es_score, route_key, key="haohaoxuexi"):
-    result_dict = {}
-    format_company_id_en(r["_source"], route_key)
-    if param_list and r["_source"]:
-        for key in param_list:
-            value = r["_source"]
-            key_list = key.split(".")
-            for key in key_list:
-                if isinstance(value, list):
-                    if value:
-                        result = []
-                        for v in value:
-                            if isinstance(v.get(key, None), list):
-                                result = result + v[key]
-                            else:
-                                result.append(v.get(key, None))
-                        value = result
-                elif isinstance(value, dict):
-                    if value:
-                        value = value.get(key, None)
-                else:
-                    pass
-            if result_dict.get(key) is None:
-                if value is not None:
-                    result_dict[key] = value
-    else:
-        result_dict = r["_source"]
-    if is_need_decrypt:
-        r["_id"] = AES.encrypt(key)
-    result_dict["_id"] = r["_id"]
-    if is_need_es_score:
-        result_dict["_score"] = r["_score"]
-    return result_dict
-
-
-def es_condition_by_match_phrase(bool_list, column, param, slop=0):
-    if param:
-        if isinstance(param, list):
-            bool_list.append({
-                "match_phrase": {
-                    column: {
-                        "query": param[0],
-                        "slop": slop
-                    }
-                }
-            })
-        if isinstance(param, str):
-            bool_list.append({
-                "match_phrase": {
-                    column: {
-                        "query": param,
-                        "slop": slop
-                    }
-                }
-            })
-
-
-def es_condition_by_match(bool_list, column, param):
-    if param:
-        if isinstance(param, list):
-            bool_list.append({
-                "match": {
-                    column: {
-                        "query": param[0],
-                    }
-                }
-            })
-        if isinstance(param, str):
-            bool_list.append({
-                "match": {
-                    column: {
-                        "query": param,
-                    }
-                }
-            })
-
-
-def es_condition_by_not_null(boo_must_list, column, param):
-    if param:
-        boo_must_list.append({
-            "exists": {
-                "field": column
-            }
-        })
-
-
-def es_condition_by_range(bool_must_list, column, date_list, is_contain_end_date=False, is_contain_start_date=True):
-    if date_list:
-        range_dict = {}
-        if date_list[0]:
-            if is_contain_start_date:
-                range_dict["gte"] = date_list[0]
-            else:
-                range_dict["gt"] = date_list[0]
-        if len(date_list) == 2 and date_list[1]:
-            end = date_list[1]
-            if is_contain_end_date:
-                range_dict["lte"] = end
-            else:
-                range_dict["lt"] = end
-
-        if range_dict:
-            bool_must_list.append({
-                "range": {
-                    column: range_dict
-                }})
-
-
-def es_condition_by_terms(bool_must_list, column, param_list, is_need_decrypt=False, key="haohaoxuexi"):
-    if param_list:
-        param_list = [i for i in param_list if i not in [None, "", "all"]]
-        if is_need_decrypt:
-            for index, _id in enumerate(param_list):
-                # noinspection PyBroadException
-                try:
-                    _id = AES.decrypt(key, _id)
-                    param_list[index] = int(_id)
-                except Exception:
-                    pass
-        if param_list:
-            bool_must_list.append({
-                "terms": {
-                    column: param_list
-                }})
-
-
-def es_condition_by_wildcard(bool_list, column, param):
-    if param:
-        bool_list.append({"wildcard": {column: f"*{param}*"}})
-
-
-def es_condition_by_exist(bool_must_list, param, is_exists="是"):
-    if param:
-        if is_exists == "是" or is_exists == "true" or is_exists is True:
-            bool_must_list.append({
-                "exists": {
-                    "field": param
-                }})
-        else:
-            bool_must_list.append({
-                "bool": {
-                    "must_not": [
-                        {
-                            "exists": {
-                                "field": param
-                            }
-                        }
-                    ]
-                }
-            })
-
-
-def es_condition_by_exist_or_not(bool_must_list, param_dict):
-    if param_dict:
-        for key in param_dict:
-            if param_dict[key] in ["是", "true", True]:
-                bool_must_list.append({
-                    "exists": {
-                        "field": key
-                    }})
-            else:
-                bool_must_list.append({
-                    "bool": {
-                        "must_not": [
-                            {
-                                "exists": {
-                                    "field": key
-                                }
-                            }
-                        ]
-                    }
-                })
-
-
-def es_condition_by_not_in(bool_must_list: list = None, column="", param_list=None):
-    if param_list:
-        bool_must_list.append({
-            "bool": {
-                "must_not": {
-                    "terms": {
-                        column: param_list
-                    }}
-            }
-        })
-
-
-def es_condition_by_geo_shape(bool_must_list: list = None, column="", polygon=None, geo_type="MultiPolygon",
-                              relation="intersects"):
-    if polygon:
-        bool_must_list.append({
-            "geo_shape": {
-                column: {
-                    "shape": {
-                        "type": geo_type,
-                        "coordinates": polygon
-                    },
-                    "relation": relation
-                }
-            }
-        })
-
-
-def format_bool_must_and_should(bool_must_list, bool_should_more_list):
-    if bool_should_more_list:
-        for bool_should in bool_should_more_list:
-            bool_must_list.append({
-                "bool": {
-                    "should": bool_should
-                }
-            })
-
-
-def format_bool_must_and_must_not(bool_must_list, bool_must_not_more_list):
-    if bool_must_not_more_list:
-        for bool_must_not in bool_must_not_more_list:
-            bool_must_list.append({
-                "bool": {
-                    "must_not": bool_must_not
-                }
-            })
-
-
-def parse_es_sort_list(column=None, order=None):
-    if column and order:
-        if order == "asc":
-            sort_list = [
-                {
-                    column: {
-                        "order": order,
-                        "missing": "_last"
-                    }
-                }
-            ]
-        else:
-            sort_list = [
-                {
-                    column: {
-                        "order": order,
-                        "missing": "_last"
-                    }
-                }
-            ]
-    else:
-        sort_list = []
-
-    return sort_list
-
-
-def es_condition_by_geo_distance(bool_must_list: list = None, column="", geo_distance=None):
-    if geo_distance:
-        bool_must_list.append({
-            "geo_distance": {
-                "distance": "{}{}".format(geo_distance.get("radius", 0), geo_distance.get("unit", "km")),
-                column: {
-                    "lat": geo_distance.get("lat", 0),
-                    "lon": geo_distance.get("lon", 0),
-                }
-            }
-        })
-
-
-def es_mapping2dict(mapping):
-    mapping_dict = dict()
-
-    if isinstance(mapping, dict):
-        if "properties" in mapping:
-            for k, v in mapping.get("properties").items():
-                if isinstance(v, dict):
-                    if "properties" not in v:
-                        if "fields" not in v and "type" in v:
-                            field_type = v.get("type")
-                            mapping_dict[k] = field_type
-                        elif "fields" in v and "type" in v:
-                            field_type = v.get("type")
-                            mapping_dict[k] = field_type
-                            if isinstance(v.get("fields"), dict):
-                                for fk, fv in v.get("fields").items():
-                                    if "type" in fv:
-                                        mapping_dict[f"{k}.{fk}"] = fv.get("type")
-
-                    else:
-                        mapping_dict[k] = es_mapping2dict(v)
-
-    return mapping_dict

lesscode_tag-0.0.6/lesscode_tag/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.6"