from typing import Dict
from onredis import onredis, set_redis_client, get_redis_client
import redis


@onredis
class Scores:
    total: float = 0
    count: int = 0
    total_per_type: Dict[str, float] = {} # <-- this is field is going to be a hash store in Redis
    count_per_type: Dict[str, float] = {}

    def global_avg(self):
        return self.total / self.count

    def avg(self, key):
        return self.total_per_type[key] / self.count_per_type[key]

    def add(self, key, value):
        with self.transaction() as t:  
            # from now, all the fields are local values
            self.total += value
            self.count += 1
            self.total_per_type[key] = self.total_per_type.get(key, 0) + value
            self.count_per_type[key] = self.count_per_type.get(key, 0) + 1
            # when the transaction exits, all the value are written to Redis 
            # except if t.discard() has been called
            #
            # the end of the transaction can raise redis.exceptions.WatchError
            # if another thread or process has changed the same object

set_redis_client(redis.Redis(unix_socket_path='./redis/docker/redis.sock'))

scores = Scores()  # <-- this is a singleton Scores() elsewhere is going to return the same object

scores.add('debian', 3.5)
scores.add('fedora', 3.4)
scores.add('debian', 4.5)
scores.add('ubuntu', 3)
scores.add('ubuntu', 4.1)
print('global_avg=', scores.global_avg())
print('avg("ubuntu")=', scores.avg("ubuntu"))
print('data=', scores)

####################

print('\nRedis keys\n')
redis_client = get_redis_client()
for k in redis_client.keys():
    try:
        v = redis_client.get(k) 
    except redis.exceptions.ResponseError:
        v = redis_client.hgetall(k)
    print(k, '=', v)