tord/common.py

   1 import os
   2 import pickle
   3 from time import time as clock
   4 import sys
   5 import logging
   6 import traceback
   7
   8 log_format = "[%(levelname)-8s] %(name)s:%(module)s:%(lineno)d %(message)s"
   9 logging.basicConfig(level=logging.DEBUG, format=log_format, stream=sys.stderr)
  10 log = logging.getLogger()
  11
  12 def timer(f):
  13   def wrapper(*args, **kwargs):
  14     s = clock()
  15     r = f(*args, **kwargs)
  16     log.info("timing %s: %s" % (str(f), str(clock()-s)))
  17     return r
  18   return wrapper
  19
  20 def test(f):
  21   def wrapper(*args, **kwargs):
  22     try: return f(*args, **kwargs)
  23     except:
  24       traceback.print_exc()
  25       log.error("error: " + str(f))
  26   return wrapper
  27
  28 class FakeIO:
  29   def __init__(self, writer, flusher = lambda: None):
  30     self.writer = writer
  31     self.flusher = flusher
  32
  33   def write(self, s): self.writer(s)
  34   def flush(self): self.flusher()
  35
  36 class Config:
  37   def __init__(self, filename, defaults=None):
  38       self.config = {}
  39       self.set_functions = {}
  40       if defaults: self.config = defaults
  41       self.config_file = get_config_dir(filename)
  42       self.load(self.config_file)
  43       self.save()
  44
  45   def __del__(self):
  46       self.save()
  47
  48   def __getitem__(self, key):
  49       return self.config[key]
  50
  51   def __setitem__(self, key, value):
  52       self.config[key] = value
  53
  54   def items(self):
  55     return self.config.items()
  56
  57   def get_config(self):
  58     return self.config
  59
  60   def load(self, filename=None):
  61       if filename is None:
  62           filename = self.config_file
  63       try:
  64           print filename
  65           pkl_file = open(filename, "rb")
  66           filedump = pickle.load(pkl_file)
  67           self.config.update(filedump)
  68           pkl_file.close()
  69       except IOError:
  70           log.error("IOError: Unable to load file '%s'", filename)
  71       except EOFError:
  72           pkl_file.close()
  73
  74   def save(self, filename=None):
  75       if filename is None:
  76           filename = self.config_file
  77       try:
  78           pkl_file = open(filename, "wb")
  79           pickle.dump(self.config, pkl_file)
  80           pkl_file.close()
  81       except IOError:
  82           log.error("IOError: Unable to save file '%s'", filename)
  83
  84   def get(self, key):
  85       try:
  86           value = self.config[key]
  87           return value
  88       except KeyError:
  89           log.error("Key does not exist, returning None")
  90           return
  91
  92   def register_set_function(self, key, function, apply_now=True):
  93       self.set_functions[key] = function
  94       if apply_now:
  95         log.info("Applying %s with %s" % (key, str(self.config[key])))
  96         self.set_functions[key](key, self.config[key])
  97       else:
  98         log.debug("Registering function for %s key..", key)
  99
 100   def apply_all(self):
 101       log.debug("Running all set functions..")
 102       for key in self.set_functions.keys():
 103           self.set_functions[key](key, self.config[key])
 104
 105 def aright(x, w): return x.rjust(w)
 106 def aleft(x, w): return x.ljust(w)
 107 def acenter(x, w): return x.center(w)
 108
 109 def toggle(f1, f2, a1=(), a2=()):
 110   def true(x): return True
 111   return lambda k,v: v and true(f1(*a1)) or f2(*a2)
 112
 113 def get_stat(obj, k, v = {}, f = {}):
 114   if k in v: return v[k]
 115   if k in f: return f[k]()
 116   return getattr(obj, k)
 117
 118 def fsize(fsize_b, divide = 1024.0):
 119     fsize_kb = float (fsize_b / divide)
 120     if fsize_kb < 1000:
 121         return ("%3.1fK")%fsize_kb
 122     fsize_mb = float (fsize_kb / divide)
 123     if fsize_mb < 1000:
 124         return ("%3.1fM")%fsize_mb
 125     fsize_gb = float (fsize_mb / divide)
 126     return ("%3.1fG")%fsize_gb
 127
 128 def fpcnt(dec):
 129     return '%3.3f%%'%(dec * 100)
 130
 131 def fratio(ratio):
 132     return '%2.2f'%(ratio)
 133
 134 def fbar(progress, width=10):
 135     progress_chars = int(progress * width)
 136     return (progress_chars * '#' + (width - progress_chars) * '-')
 137
 138 def fspeed(bps):
 139   if bps < 0: return 'inf'
 140   return fsize(bps, 1000)
 141
 142 def fpeers(x, max=999):
 143   if x > max: return 'inf'
 144   return str(x)
 145
 146 def ftime(seconds):
 147     if seconds < 60: return '%2ds'%(seconds)
 148     minutes = int(seconds/60)
 149     seconds = seconds % 60
 150     if minutes < 60: return '%2dm %2ds'%(minutes, seconds)
 151     hours = int(minutes/60)
 152     minutes = minutes % 60
 153     if hours < 24: return '%2dh %2dm'%(hours, minutes)
 154     days = int(hours/24)
 155     hours = hours % 24
 156     if days < 7: return '%2dd %2dh'%(days, hours)
 157     weeks = int(days/7)
 158     days = days % 7
 159     if weeks < 10: return '%2dw %2dd'%(weeks, days)
 160     return 'unknown'
 161
 162 def fstate(x):
 163   def queue(x):
 164     if x < 0: return '  '
 165     if x > 999: return '---'
 166     return str(x)
 167   def state(s):
 168     state = ['queue', 'hash', 'meta', 'down', 'finish', 'seed', 'init']
 169     return state[s][0]
 170   def managed(x):
 171     if x: return 'm'
 172     return ' '
 173   def paused(p):
 174     if p: return 'p'
 175     return ' '
 176   q, m, s, p = x
 177   return "%3s %c%c%c" % (queue(q), managed(m), paused(p), state(s))
 178
 179 def get_default_dir(extra=None):
 180   path = os.environ.get("HOME")
 181   if extra:
 182     path = os.path.join(path, extra)
 183     try: os.makedirs(path)
 184     except: pass
 185   return path
 186
 187 def get_config_dir(filename=None):
 188     path = os.path.join(get_default_dir(), ".tore/")
 189
 190     try: os.mkdir(path)
 191     except: pass
 192
 193     if filename: path = os.path.join(path, filename)
 194     return path