miniconda3/envs/active_proaction/lib/python3.10/site-packages/bytedabase/client.py

# coding: utf-8

"""Client for abase"""

from __future__ import absolute_import, division, print_function, unicode_literals

import datetime
import functools
import time

import bytedredis
from redis.client import Pipeline as RedisPipeline
from redis.exceptions import (
    ConnectionError,
    TimeoutError,
)

SIMPLE_ABASE_COMMANDS = [
    "decr",
    "decrby",
    "expire",
    "expireat",
    "get",
    "incr",
    "incrby",
    "lpush",
    "lpop",
    "lindex",
    "llen",
    "lrange",
    "persist",
    "pexpire",
    "psetex",
    "psetex",
    'rpush',
    "pttl",
    "set",
    "setex",
    "setnx",
    "ttl",
    "hset",
    "hget",
    "hdel",
]


class Client(object):
    def __init__(self, psm, table, from_url=True, **kwargs):
        """Create abase client.

        :param psm: abase service name
        :type psm: str
        :param table: abase table name
        :type tabale: str
        :param socket_timeout: set the underlying socket's timeout
        :type socket_timeout: float
        :param socket_connect_timeout: set the connect timeout for underlying socket
        :type socket_connect_timeout: float
        :param decode_responses: set True to return strings, False(default) to bytes
        :type decode_responses: bool
        """
        available_params = ["socket_timeout", "socket_connect_timeout",
            "decode_responses", "password"]
        redis_kwargs = {}
        for k in available_params:
            if k in kwargs:
                redis_kwargs[k] = kwargs[k]
        self._psm = psm
        self._table = table
        if from_url:
            self._redis_client = bytedredis.Client.from_url("redis://?redis_psm=" + psm, **redis_kwargs)
        else:
            self._redis_client = bytedredis.Client(redis_psm=psm, **redis_kwargs)

    def _compose_abase_key(self, key):
        return "[%s]%s" % (self._table, key)

    @functools.wraps(bytedredis.Client.exists)
    def exists(self, *keys):
        return self._redis_client.exists(*(self._compose_abase_key(key) for key in keys))

    @functools.wraps(bytedredis.Client.delete)
    def delete(self, *keys):
        return self._redis_client.delete(*(self._compose_abase_key(key) for key in keys))

    @functools.wraps(bytedredis.Client.mget)
    def mget(self, keys, *args):
        return self._redis_client.mget((self._compose_abase_key(key) for key in keys), *args)

    @functools.wraps(bytedredis.Client.mset)
    def mset(self, mapping):
        mapping = {self._compose_abase_key(k): v for k, v in mapping.items()}
        return self._redis_client.mset(mapping)

    @functools.wraps(bytedredis.Client.eval)
    def eval(self, script, numkeys, *keys_and_args):
        keys = keys_and_args[:numkeys]
        args = keys_and_args[numkeys:]
        keys = [self._compose_abase_key(key) for key in keys]
        keys.extend(args)
        return self._redis_client.eval(script, numkeys, *keys)

    @functools.wraps(bytedredis.Client.evalsha)
    def evalsha(self, script, numkeys, *keys_and_args):
        keys = keys_and_args[:numkeys]
        args = keys_and_args[numkeys:]
        keys = [self._compose_abase_key(key) for key in keys]
        keys.extend(args)
        return self._redis_client.evalsha(script, numkeys, *keys)

    def scanrow(self, row, limit, offset=0, target=None):
        row = self._compose_abase_key(row)
        args = [row, limit, offset]
        if target:
            args.append(target)
        return self._redis_client.execute_command("SCANROW", *args)

    def xget(self, key):
        return self._redis_client.execute_command("XGET", self._compose_abase_key(key))

    def xset(self, key, value, generation, ex=None, px=None):
        if ex is not None and px is not None:
            raise ValueError("ex and px must not be specified both")

        args = [self._compose_abase_key(key), value, generation]
        if ex is not None:
            args.append("EX")
            if isinstance(ex, datetime.timedelta):
                ex = int(ex.total_seconds())
            args.append(ex)
        if px is not None:
            args.append("PX")
            if isinstance(px, datetime.timedelta):
                px = int(px.total_seconds() * 1000)
            args.append(px)
        return self._redis_client.execute_command("XSET", *args)

    def append(self, key, value, ttl=None):
        args = [self._compose_abase_key(key), value]
        if ttl is not None:
            args.append(ttl)
        return self._redis_client.execute_command("APPEND", *args)

    def prepend(self, key, value, ttl=None):
        args = [self._compose_abase_key(key), value]
        if ttl is not None:
            args.append(ttl)
        return self._redis_client.execute_command("PREPEND", *args)

    def pipeline(self):
        return AbasePipeline(self._table,
                             self._redis_client.connection_pool,
                             self._redis_client.response_callbacks,
                             self._redis_client._metrics_client)


class AbasePipeline(RedisPipeline):
    SUPPORTED_COMMANDS = set([
        "GET",
        "SET",
        "DEL",
        "SETEX",
        "SETNX",
        "INCR",
        "INCRBY",
        "DECR",
        "DECRBY",
        "TTL",
        "PTTL",
        "PSETEX",
        "EXPIRE",
        "EXPIREAT",
        "PEXPIRE",
        "PERSIST",
        "LPUSH",
        "RPUSH",
        "LRANGE",
        "Hgetall",
        "Hset",
        "Hdrop",
        "Hsetexpires"
    ])

    def __init__(self, table, conn_pool, response_callbacks, metrics_client, *args, **kwargs):
        transaction = False
        shard_hint = None
        super(AbasePipeline, self).__init__(conn_pool, response_callbacks, transaction, shard_hint)
        self._table = table
        self._metrics_client = metrics_client

    def _get_connection(self):
        if self.connection:
            return self.connection
        self.connection = self.connection_pool.get_connection("MULTI", self.shard_hint)
        return self.connection

    def execute_command(self, *args, **kwargs):
        cmd = args[0]
        if cmd not in AbasePipeline.SUPPORTED_COMMANDS:
            raise ValueError("{cmd} is not supported, supported cmds are [{cmds}]".format(
                cmd=cmd, cmds=", ".join(list(AbasePipeline.SUPPORTED_COMMANDS))
            ))
        args = self._transfer_to_abase_cmd(cmd, args[1:])
        return super(AbasePipeline, self).execute_command(*args, **kwargs)

    def execute(self, raise_on_error=True):
        cmd_name = "PIPELINE"
        ok = True
        start = time.time()
        conn = self._get_connection()
        try:
            return self._execute(conn, raise_on_error)
        except Exception:
            ok = False
            raise
        finally:
            cost = int((time.time() - start) * 1000 * 1000)
            rip = "%s_%s" % (conn.host, conn.port)
            self._metrics_client.emit(ok, latency=cost, method=cmd_name, rip=rip)

    def _execute(self, conn, raise_on_error):
        try:
            return self._execute_pipeline(conn, self.command_stack, raise_on_error)
        except (ConnectionError, TimeoutError) as e:
            conn.disconnect()
            # if retry_on_timeout is not set, or the error is not
            # a TimeoutError, raise it
            if not (conn.retry_on_timeout and isinstance(e, TimeoutError)):
                raise
            # retry a TimeoutError when retry_on_timeout is set
            return self._execute_pipeline(conn, self.command_stack, raise_on_error)
        finally:
            self.reset()

    def _transfer_to_abase_cmd(self, cmd, redis_args):
        abase_args = [cmd]
        for idx, arg in enumerate(redis_args):
            if idx == 0 or cmd == 'DEL':
                abase_args.append(self._compose_abase_key(arg))
            else:
                abase_args.append(arg)
        return abase_args

    def _compose_abase_key(self, key):
        return "[%s]%s" % (self._table, key)


def compose_simple_abase_command(command):
    redis_command = getattr(bytedredis.Client, command)

    @functools.wraps(redis_command)
    def abase_command(self, *args, **kwargs):
        args = list(args)
        redis_command = getattr(self._redis_client, command)
        key = self._compose_abase_key(args.pop(0))
        return redis_command(key, *args, **kwargs)

    return abase_command


for command in SIMPLE_ABASE_COMMANDS:
    if hasattr(bytedredis.Client, command):
        setattr(Client, command, compose_simple_abase_command(command))