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