re-common 0.2.54__py3-none-any.whl → 2.0.1__py3-none-any.whl

re_common/baselibrary/tools/myparsel.py

@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Time    : 2020/9/16 13:18
-# @Author  : suhong
-# @File    : mcss.py
-# @Software: PyCharm
-import jsonpath as jsonpath
-from parsel import Selector
-
-
-class MParsel(object):
-    def __init__(self, html="", logger=None):
-        if logger is None:
-            from re_common.baselibrary import MLogger
-            logger = MLogger().streamlogger
-        self.logger = logger
-        self.html = html
-        if self.html:
-            self.set_sel(self.html)
-
-    def set_sel(self, html):
-        self.html = html
-        self.sel = Selector(html)
-
-    def css_parsel(self, sel, css_selector={}):
-        assert self.html, '解析html时html不能为空'
-        dicts = {}
-        parent = None
-        if css_selector:
-            # 保证 parent 存在时优先解析
-            if "parent" in css_selector.keys():
-                parent = sel.css(css_selector["parent"])
-            for key, value in css_selector.items():
-                if isinstance(value, dict):
-                    if key == "children":
-                        # assert parent, "parent 不存在"
-                        list_c = []
-                        for p_item in parent:
-                            list_c.append(self.css_parsel(p_item, value))
-                        dicts[key] = list_c
-                    else:
-                        dicts[key] = self.css_parsel(sel, value)
-                    continue
-                if key == "parent":
-                    continue
-                dicts[key] = sel.css(value).getall()
-        return dicts
-
-    def css_parsel_html(self, css_selector={}):
-        if self.html != "" and css_selector:
-            dict_ = dict()
-            for key, value in css_selector.items():
-                dict_[key] = self.sel.css(value).getall()
-            return True, dict_
-        else:
-            return False, ""
-
-    def xpath_parsel(self, sel, xpath_selector={}):
-        assert self.html, '解析html时html不能为空'
-        dicts = {}
-        parent = None
-        if xpath_selector:
-            # 保证 parent 存在时优先解析
-            if "parent" in xpath_selector.keys():
-                parent = sel.xpath(xpath_selector["parent"])
-            for key, value in xpath_selector.items():
-                if isinstance(value, dict):
-                    if key == "children":
-                        # assert parent, "parent 不存在"
-                        list_c = []
-                        for p_item in parent:
-                            list_c.append(self.xpath_parsel(p_item, value))
-                        dicts[key] = list_c
-                    else:
-                        dicts[key] = self.xpath_parsel(sel, value)
-                    continue
-                if key == "parent":
-                    continue
-                dicts[key] = sel.xpath(value).getall()
-        return dicts
-
-    def xpath_parsel_html(self, html="", xpath_selector={}):
-        if html != "" and xpath_selector:
-            sel = Selector(html)
-            dict_ = dict()
-            for key, value in xpath_selector.items():
-                dict_[key] = sel.xpath(value).getall()
-            return True, dict_
-        else:
-            return False, ""
-
-    def json_parsel(self, sel_json, json_selector={}):
-        assert self.html, '解析html时html不能为空'
-        re_dict = {}
-        if json_selector:
-            for key, value in json_selector.items():
-                re_dict[key] = jsonpath(sel_json, value)
-        dicts = {
-            "json_raw":sel_json,
-            "data":re_dict
-        }
-        return dicts
-
-    def asd(self):
-        pass

re_common/baselibrary/tools/rename_dir_file.py

@@ -1,37 +0,0 @@
-"""
-重命名目录下的文件
-"""
-from re_common.baselibrary.utils.basedir import BaseDir
-from re_common.baselibrary.utils.basefile import BaseFile
-
-
-def get_next_suffix(num):
-    num = num + 1
-    return "_" + str(num).zfill(4)
-
-
-def rename_db3(dirpath, rename, start=0):
-    """
-    重命名db3　文件　以后缀_001 或者　_000 开始
-    :param rename:
-    :param start: 1 代表_001　0代表_000
-    :return:
-    """
-    """
-    
-    :param dirpath: 
-    :param rename: 
-    :param start: 
-    :return: 
-    """
-
-    for file in BaseDir.get_dir_all_files(dirpath):
-        if file.endswith(".db3"):
-            BaseDir.get_upper_dir(file, -1)
-            renamepath = BaseFile.get_new_path(dirpath, rename + get_next_suffix(start) + ".db3")
-            BaseFile.rename_file(file, renamepath)
-            start = start + 1
-
-
-rename_db3(r"\\192.168.31.65\d$\zt_data_db3\zt_normal_grx\zt_cnki_qk_20200323", "zt_cnki_qk_20200323")
-rename_db3(r"\\192.168.31.65\d$\zt_data_db3\zt_normal_grx\zt_wf_qk_20200323", "zt_wf_qk_20200323")

re_common/baselibrary/tools/sequoiadb_utils.py

@@ -1,398 +0,0 @@
-from typing import Union
-
-from pysequoiadb import client
-from pysequoiadb.collection import INSERT_FLG_DEFAULT
-from pysequoiadb.lob import LOB_READ, LOB_WRITE
-
-
-class SequoiadbUtils(object):
-
-    def __init__(self):
-        self.db_data = None
-        self.db = None
-        self.cs = None
-        self.cl = None
-        self.list_hosts = None
-
-    def set_db_data(self, db_data: dict):
-        self.db_data = db_data
-        return self
-
-    def set_list_hosts(self, list_hosts):
-        self.list_hosts = list_hosts
-        return self
-
-    def build(self):
-        self.link_db()
-        self.link_col()
-        return self
-
-    def set_cl(self, cl):
-        self.cl = cl
-
-    def link_db(self):
-        """
-        初始化 host, port, user, password ，连接
-        """
-        host = self.db_data.get("host", "")
-        port = self.db_data.get("port", "")
-        user = self.db_data.get("user", "")
-        password = self.db_data.get("password", "")
-        try:
-            self.db = client(host=host, service=port, user=user, psw=password)
-            if self.list_hosts:
-                # self.list_hosts = [
-                #     {'host': '192.168.31.21', 'service': '11810'},
-                #     {'host': '192.168.31.22', 'service': '11810'},
-                #     {'host': '192.168.31.23', 'service': '11810'},
-                #     {'host': '192.168.31.24', 'service': '11810'},
-                #     {'host': '192.168.31.25', 'service': '11810'},
-                #     {'host': '192.168.31.26', 'service': '11810'},
-                #     {'host': '192.168.31.27', 'service': '11810'},
-                #     {'host': '192.168.31.219', 'service': '11810'},
-                #     {'host': '192.168.31.208', 'service': '11810'}
-                # ]
-                self.db.connect_to_hosts(self.list_hosts, user=user, psw=password)
-            return self.db
-        except Exception as e:
-            raise e
-
-    def link_col(self):
-        collection_space_name = self.db_data.get("collection_space_name", "")
-        collection_name = self.db_data.get("collection_name", "")
-        is_create = self.db_data.get("is_create", "false")
-        try:
-            self.cl = self.db.get_collection("{}.{}".format(collection_space_name, collection_name))
-            return self.cl
-        except:
-            print('集合空间或者集合不存在')
-            if is_create == "true":
-                try:
-                    self.cs = self.db.create_collection_space(collection_space_name)
-                    print('创建集合空间  ', collection_space_name)
-                except:
-                    self.cs = self.db.get_collection_space(collection_space_name)
-                try:
-                    self.cl = self.cs.create_collection(collection_name)
-                    print('创建集合空间  ', collection_name)
-                    return self.cl
-                except:
-                    self.cl = self.cs.get_collection(collection_name)
-
-    def insert(self, record: dict, cl=None):
-        """
-        插入数据
-        :return A ObjectId object of record inserted. eg: { '_id': ObjectId('5d5149ade3071dce3692e93b') }
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.insert(record)
-
-    def replace_one(self, doc, cl=None, **kwargs):
-        """
-        更新数据
-        rule:  更新数据
-        kwargs:
-            condition: 匹配规则
-            hint: https://doc.sequoiadb.com/cn/SequoiaDB-cat_id-1432190835-edition_id-300
-            flags: 默认为0  UPDATE_FLG_KEEP_SHARDINGKEY 更新规则中的分片键在执行时没有被过滤更新或插入。
-            如果不给flags,不保留更新规则中的分区键字段，只更新非分区键字段。否则 保留更新规则中的分区键字段。
-            指定 flags 参数：保留更新规则中的分区键字段。因为目前不支持更新分区键，所以会报错。
-        """
-        if cl is None:
-            cl = self.cl
-        rule = {"$replace": doc}
-        return cl.update(rule, **kwargs)
-
-    def bulk_insert(self, flag: int, records: Union[list, tuple], cl=None):
-        """
-        插入多条数据
-        :param flag:
-         INSERT_FLG_DEFAULT : 当设置INSERT_FLG_DEFAULT时，当记录命中索引时，数据库将停止插入键重复错误。，插入正常也不会返回id
-         INSERT_FLG_CONTONDUP : 如果记录命中索引键重复错误，数据库将跳过它
-         INSERT_FLG_RETURN_OID : 返回记录中“_id”字段的值。，如果有重复会报错
-         INSERT_FLG_REPLACEONDUP : 如果记录命中索引键重复错误，数据库将用插入新记录，然后继续插入。
-        :param records:
-        :return:
-        当flag不等于INSERT_FLG_RETURN_OID时，将返回一个空字典, eg: { }.
-        eg: { '_id': [ObjectId('5d514a25c764c60acb58de38'), ObjectId('5d514a25c764c60acb58de39')]}
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.bulk_insert(flag, records)
-
-    def insert_with_flag(self, record, flag=INSERT_FLG_DEFAULT, cl=None):
-        """
-        插入数据，并可以选择flags
-        和 bulk_insert 一样的标志，这样可以实现replace
-        :param record:
-        :param flag:
-        :return:
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.insert_with_flag(record, flag)
-
-    def delete(self, cl=None, **kwargs):
-        """
-        删除数据
-        condition: 匹配规则后，删除文档,如果没有提供,删除所有文档
-        在 https://doc.sequoiadb.com/cn/sequoiadb-cat_id-1432190843-edition_id-300对hint
-        hint: 指定访问计划（v3.0后意义不大）
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.delete(**kwargs)
-
-    def update(self, rule: dict, cl=None, **kwargs):
-        """
-        更新数据
-        rule:  更新数据
-        kwargs:
-            condition: 匹配规则
-            hint: https://doc.sequoiadb.com/cn/SequoiaDB-cat_id-1432190835-edition_id-300
-            flags: 默认为0  UPDATE_FLG_KEEP_SHARDINGKEY 更新规则中的分片键在执行时没有被过滤更新或插入。
-            如果不给flags,不保留更新规则中的分区键字段，只更新非分区键字段。否则 保留更新规则中的分区键字段。
-            指定 flags 参数：保留更新规则中的分区键字段。因为目前不支持更新分区键，所以会报错。
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.update(rule, **kwargs)
-
-    def upsert(self, rule, cl=None, **kwargs):
-        """
-        该函数用于更新集合记录。upsert 方法跟 update 方法都是对记录进行更新，不同的是当使用 cond 参数在集合中匹配不到记录时，update 不做任何操作，而 upsert 方法会做一次插入操作
-        https://doc.sequoiadb.com/cn/sequoiadb-cat_id-1432190848-edition_id-500
-        :param rule: 更新规则
-        :param kwargs: condition: 条件
-                        hint: 指定索引
-                        setOnInsert： 在做插入操作时向插入的记录中追加字段。
-                        flags：UPDATE_FLG_KEEP_SHARDINGKEY 默认不给
-        :return:
-        """
-        if cl is None:
-            cl = self.cl
-        cl.upsert(rule, **kwargs)
-
-    def query(
-            self,
-            condition: dict = None,
-            selector: dict = None,
-            order_by: dict = None,
-            hint: dict = None,
-            num_to_skip: int = 0,
-            num_to_return: int = -1,
-            flags: int = 0,
-            cl=None):
-        """
-        https://doc.sequoiadb.com/cn/sequoiadb-cat_id-1552489127-edition_id-500
-        查询数据
-        condition:为空时，查询所有记录；不为空时，查询符合条件记录。如：{"age":{"$gt":30}}。关于匹配条件的使用，可参考匹配符
-        selector:为空时，返回记录的所有字段；如果指定的字段名记录中不存在，则按用户设定的内容原样返回。如：{"name":"","age":"","addr":""}。字段值为空字符串即可，数据库只关心字段名。关于选择条件的使用，可参考选择符。
-        order_by:指定结果集按指定字段名排序的情况。字段名的值为1或者-1，如：{"name":1,"age":-1}。1代表升序；-1代表降序。 如果不设定 sort 则表示不对结果集做排序。
-        hint:指定查询使用索引的情况。字段名可以为任意不重复的字符串，数据库只关心字段值。
-        num_to_skip:自定义从结果集哪条记录开始返回。默认值为0，表示从第一条记录开始返回。
-        num_to_return：自定义返回结果集的记录条数。默认值为-1，表示返回从skipNum位置开始到结果集结束位置的所有记录。
-        flags： QUERY_FLG_WITH_RETURNDATA:强制使用指定的提示进行查询，如果数据库没有提示分配的索引，则查询失败
-                query_flg_parallelall:启用并行子查询，每个子查询将完成扫描数据的不同部分
-                QUERY_FLG_FORCE_HINT:一般情况下，直到游标从数据库获取数据，查询才会返回数据，当添加此标志时，在查询响应中返回数据，将会更加高性能
-                QUERY_PREPARE_MORE:启用查询时准备更多数据
-                QUERY_FLG_FOR_UPDATE:当事务被打开且事务隔离级别为“RC”时，事务锁将不会在事务提交或回滚之前释放。
-        """
-        if condition is None:
-            condition = {}
-        if selector is None:
-            selector = {}
-        if order_by is None:
-            order_by = {}
-        if hint is None:
-            hint = {}
-        if cl is None:
-            cl = self.cl
-        return cl.query(condition=condition,
-                        selector=selector,
-                        order_by=order_by,
-                        hint=hint,
-                        num_to_skip=num_to_skip,
-                        num_to_return=num_to_return,
-                        flags=flags)
-        # data_list = list()
-        # while 1:
-        #     try:
-        #         result = results.next()
-        #         data_list.append(result)
-        #     except:
-        #         break
-        # return str(data_list)
-
-    def query_and_update(self, update, cl=None, **kwargs):
-        """
-
-        :param update:  更新的规则
-        :param kwargs: 查询条件，和上面查询一样多一个参数
-                return_new bool 当为True时，返回更新后的文档，而不是原始文档
-        :return: 返回查询的结果
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.query_and_update(update, **kwargs)
-
-    def query_and_remove(self, cl=None, **kwargs):
-        """
-        查询删除
-        条件和查询完全一样
-        :param kwargs:
-        :return: 返回查询的结果
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.query_and_remove(**kwargs)
-
-    def save(self, doc, cl=None):
-        """
-        存在更新，不存在插入
-        :param doc:
-        :return:
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.save(doc)
-
-    def create_lob(self, oid=None, cl=None):
-        """
-        相当于一个空间
-        :param oid: bson.ObjectId  指定要创建的lob的oid，如果为None，则自动生成oid
-        :return:  一个objectid
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.create_lob(oid=oid)
-
-    def create_lob_id(self, timestamp=None, cl=None):
-        """
-        创建lob id
-        :param timestamp: 用于于生成lob id，如果为None则由服务器生成时间戳。
-                            格式:YYYY-MM-DD-HH.mm.ss。如:“2019-07-23 18.04.07”
-        :return: lob的一个ObjectId对象。
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.create_lob_id(timestamp=timestamp)
-
-    def open_lob(self, oid, mode=LOB_READ, cl=None):
-        """
-        打开指定的lob进行读写
-        :param oid: str/bson.ObjectId    指定的oid
-        :param mode:
-        int                  The open mode:
-                                         lob.LOB_READ for reading.
-                                         lob.LOB_WRITE for writing.
-                                         lob.LOB_SHARE_READ for share reading.
-                                         lob.LOB_SHARE_READ | lob.LOB_WRITE for both reading and writing.
-
-        :return: a lob object
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.open_lob(oid, mode)
-
-    def get_lob(self, oid, cl=None):
-        """
-        获取指定的lob
-        :param oid:  str/bson.ObjectId    The specified oid
-        :return:  a lob object
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.get_lob(oid)
-
-    def remove_lob(self, oid, cl=None):
-        """
-        删除lob
-        :param oid:  str/bson.ObjectId    The oid of the lob to be remove.
-        :return:
-        """
-        if cl is None:
-            cl = self.cl
-        cl.remove_lob(oid)
-
-    def truncate_lob(self, oid, length, cl=None):
-        """截断lob
-
-        Parameters:
-           Name     Type                 Info:
-           oid      str/bson.ObjectId    The oid of the lob to be truncated.
-           length   int/long             The truncate length
-        Exceptions:
-           pysequoiadb.error.SDBBaseError
-        """
-        if cl is None:
-            cl = self.cl
-        cl.truncate_lob(oid, length)
-
-    def list_lobs(self, cl=None, **kwargs):
-        """
-        lob 列表
-        :param kwargs:
-        Name              Type     Info:
-           - condition       dict     The matching rule, return all the lob if not provided.
-           - selected        dict     The selective rule, return the whole infomation if not provided.
-           - order_by        dict     The ordered rule, result set is unordered if not provided.
-           - hint            dict     Specified options. eg. {"ListPieces": 1} means get the detail piece info of lobs.
-           - num_to_skip     long     Skip the first numToSkip lob, default is 0.
-           - num_to_Return   long     Only return numToReturn lob, default is -1 for returning all results.
-
-        :return: a cursor object of query
-        """
-        if cl is None:
-            cl = self.cl
-        return cl.list_lobs(**kwargs)
-
-    def lob_insert(self, record: str, cl=None):
-        """
-        插入lob数据,输入字符串
-        """
-        if cl is None:
-            cl = self.cl
-        try:
-            lob_oid = cl.create_lob_id()
-            lob_obj = cl.create_lob(lob_oid)
-            lob_obj.write(record, len(record))
-            lob_obj.close()
-            return str(lob_oid)
-        except Exception as e:
-            raise e
-
-    def replace_lob(self, record: str, lob_oid: str, cl=None):
-        """
-        插入lob数据,输入字符串
-        """
-        if cl is None:
-            cl = self.cl
-        try:
-            lob_obj = cl.open_lob(lob_oid, mode=LOB_WRITE)
-            lob_obj.write(record, len(record))
-            lob_obj.close()
-            return str(lob_oid)
-        except Exception as e:
-            raise e
-
-    def lob_insert_for_file(self, filepath: str):
-        pass
-
-    def lob_query(self, oid, cl=None):
-        """
-        查询lob数据
-        """
-        if cl is None:
-            cl = self.cl
-        lob_file = cl.open_lob(oid)
-        return str(lob_file.read(lob_file.get_size()), encoding='utf-8')
-
-    def close(self):
-        self.db.disconnect()
-
-
-def get_col(sdb_util: SequoiadbUtils, collection_space_name, collection_name):
-    cl = sdb_util.db.get_collection("{}.{}".format(collection_space_name, collection_name))
-    return cl

re_common/baselibrary/tools/split_line_to_many.py

@@ -1,25 +0,0 @@
-"""
-一行文本按指定符号分割为多行文本
-"""
-
-
-class Split_2_lines(object):
-    def __int__(self):
-        pass
-
-    def split_line(self, infilepath, sign, outfilepath=None):
-        """
-        :param infilepath: 输入文件位置
-        :param sign: 分割符号
-        :param outfilepath: 输出文件位置
-        :return:
-        """
-        with open(infilepath, 'r', encoding='utf-8')as f:
-            for line in f:
-                list_ = line.split(sign)[:-1]
-                for num in list_:
-                    new_line = num + sign + "\n"
-                    with open(outfilepath, 'a', encoding='utf-8')as fw:
-                        fw.write(new_line)
-                        print(new_line)
-        print("输出{}成功".format(outfilepath))

re_common/baselibrary/tools/stringtodicts.py

@@ -1,33 +0,0 @@
-from re_common.baselibrary.utils.baselist import BaseList
-
-
-class StringToDicts(object):
-
-    def __init__(self):
-        pass
-
-    def string_to_dicts_by_equal(self, strings):
-        """
-        将string 按行分组 然后每组内使用等号分割 前面为字典的键 后面为字典的值
-        strings = ```
-        host = 192.168.31.209
-        user = root
-        passwd = vipdatacenter
-        db = data_gather_record
-        port = 3306
-        chartset = utf8
-        ```
-        :param strings:
-        :return:
-        """
-        baselistobj = BaseList()
-        lists = strings.split("\n")
-        lists = baselistobj.remove_null(lists)
-        lists = baselistobj.remove_blank_space(lists)
-        lists = baselistobj.clean_space_first_end(lists)
-        dicts = {}
-        for item in lists:
-            key = item.split("=")[0].strip()
-            values = item.split("=")[1].strip()
-            dicts[key] = values
-        return dicts

re_common/baselibrary/tools/workwechant_bot.py

@@ -1,84 +0,0 @@
-import json
-
-import requests
-
-from re_common.baselibrary.utils.baserequest import BaseRequest
-
-
-class WorkWechatBot(object):
-
-    def __init__(self,key):
-        super().__init__()
-        self.bsrequest = BaseRequest()
-        self.upurl = "https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media?key={}&type=file".format(key)
-        self.url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={}".format(key)
-
-    def sendMsg(self, data):
-        headers = {"Content-Type": "application/json"}
-        BoolResult, errString, r = self.bsrequest.base_request_post(self.url,
-                                                                    headers=headers,
-                                                                    data=data,
-                                                                    timeout=(10, 30)
-                                                                    )
-        if BoolResult:
-            dicts = json.loads(r.text)
-            if dicts["errcode"] == 0:
-                return True,dicts
-            else:
-                return False,dicts
-        else:
-            return False, errString
-
-    def uploadFile(self, files):
-        headers = {
-            "Content-Type": "multipart/form-data;"
-        }
-        r = requests.post(self.url, files=files, headers=headers)
-        # BoolResult, errString, r = self.bsrequest.base_request_post(self.url,
-        #                                                             headers=headers,
-        #                                                             files=upfile,
-        #                                                             timeout=(10, 30)
-        #                                                             )
-        print(r.text)
-
-    def sendTextMsg(self,msg,options=None):
-        data = {
-            "msgtype": "text",
-            "text": {
-                "content": msg
-             }
-        }
-        if options:
-            data["text"] .update(options)
-        return self.sendMsg(data)
-
-    def sendMarkDownMsg(self,msg,options=None):
-        data = {
-            "msgtype": "markdown",
-            "markdown": {
-                "content": msg
-             }
-        }
-        if options:
-            data["text"] .update(options)
-        return self.sendMsg(data)
-
-    def sendImage(self, msg):
-        data = {
-            "msgtype": "image",
-            "image": msg
-        }
-        return self.sendMsg(data)
-
-    def sendTxtImage(self, msg):
-        data = {
-            "msgtype": "news",
-            "articles": msg
-        }
-        return self.sendMsg(data)
-
-if __name__ == "__main__":
-    wxb = WorkWechatBot("5a822419-b7b2-4036-a136-5e75f028ddfb")
-    #wxb.sendTextMsg("额...")
-    files = {'file': ('test.txt',open(r'E:\test.txt', 'rb'),"media")}
-    wxb.uploadFile(files)