Python Redis模块封装

# -*- coding:utf-8 -*-
# @Time: 2022/8/22 14:17 
# @File: redis_data_utils.py
# @Software: PyCharm

import time

import redis
from icecream import ic
import json
from config import cfg
from datetime import datetime

ic.configureOutput(prefix=f'{datetime.now()}|> ')


def _ic(notify):
    ic(notify)


class MyEncoder(json.JSONEncoder):

    def default(self, obj):
        """
        判断是否为bytes类型的数据是的话转换成str
        :param obj:
        :return:
        """
        if isinstance(obj, bytes):
            return str(obj)
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        return json.JSONEncoder.default(self, obj)


def check_redis_connect(r):
    # 检测 redis 连接是否正常
    status = False
    while status == False:
        try:
            _ic(notify={"error": " {} 连接异常.".format(r)}) if not r.ping() else _ic(notify={"{} 连接正常.".format(r)})
            status = True
        except ConnectionRefusedError as err:
            _ic(err)
            status = False
            time.sleep(3)
        except redis.exceptions.ConnectionError as err:
            _ic(err)
            status = False
            time.sleep(3)
    return status


class ConnectionRedis(object):
    """
    redis数据库连接池创建
    """
    @staticmethod
    def _conn_r():
        RDB = 6 if cfg.REDIS.DB != 6 else cfg.REDIS.DB
        pool = redis.ConnectionPool(
            host=cfg.REDIS.HOST,
            port=cfg.REDIS.PORT,
            db=RDB,
            password=cfg.REDIS.PASSWORD,
            decode_responses=True
        )
        redis_conn = redis.StrictRedis(connection_pool=pool, decode_responses=True)

        return redis_conn

    @classmethod
    def _set_r(cls, data):
        """
        ;;写入键值对
        ;;将数据写入redis
        """
        r, input_count, exists_count, faild_count, notify = cls._conn_r(), 0, 0, 0, {}
        expire_in_seconds = cfg.REDIS.EXPIRE if cfg.REDIS.EXPIRE else None
        if check_redis_connect(r):
            for face_obj in data:
                result = json.dumps(face_obj, ensure_ascii=False, cls=MyEncoder, indent=2) if isinstance(face_obj, (
                dict, set, list, bytes)) else str(face_obj)
                if not r.exists(face_obj['id']):
                    set_status = r.set(face_obj['id'], result, ex=expire_in_seconds)
                    input_count += 1 if set_status else 0
                    faild_count += 1 if not set_status else 0
                else:
                    exists_count += 0
        notify.update({'人脸录入redis': {
            '成功(success)': str(input_count) + ' 条',
            '已存在(exists)': str(exists_count) + ' 条',
            '失败(fail)': str(faild_count) + ' 条'
        }})
        return notify

    @classmethod
    def _get_r(cls, key):
        """
        :param key 人脸 face_id:
        :return 获取数据（单个）:
        """
        data = cls._conn_r().get(key) if check_redis_connect(cls._conn_r()) else None
        return json.loads(data) if data else None

    @classmethod
    def _get_list_r(cls, face_key_list):
        """
        :param key_list 根据key_list（数据）查询对应的班级信息:
        :return:
        """
        r, not_exist_list, face_list = cls._conn_r(), [], []
        [not_exist_list.append(key) if not r.get(key) else face_list.append(json.loads(r.get(key))) for key in
         face_key_list] if check_redis_connect(r) else None
        return face_list, len(not_exist_list), len(face_list)

    @classmethod
    def _get_all_r(cls):
        """
        ;;获取所有数据
        :return:
        """
        r, redis_data_list = cls._conn_r(), []
        r_keys = r.keys() if check_redis_connect(r) else None
        [redis_data_list.append(json.loads(json.dumps(r.get(key), ensure_ascii=False, cls=MyEncoder, indent=2))) for key
         in r_keys]
        return redis_data_list

    @classmethod
    def _update_r(cls, key, value):
        """
        :note 数据更新，同 set 方法
        :param key  ID:
        :param value 数据:
        :return 状态:
        """
        r = cls._conn_r()
        if check_redis_connect(r):
            result = json.dumps(str(value)) if isinstance(value, (dict, set, list, bytes)) else str(value)
            return r.set(key, result) if r.exists(key) else None

    @classmethod
    def _del_r(cls, key):
        """
        :param key 要删除的 ID:
        :return:
        """
        r = cls._conn_r()
        return r.delete(key) if r.exists(key) else None if check_redis_connect(r) else None

    @classmethod
    def _clear_r(cls):
        """
        :每次重启清空 redis缓存，
        :return:
        """
        ic({"清空 Redis 历史缓存........"})
        r = cls._conn_r()
        return r.flushall() if check_redis_connect(r) else None