looking good

1 files changed, 0 insertions, 376 deletions

diff --git a/generate b/generate
deleted file mode 100755
index 0585b10..0000000
--- a/generate
+++ /dev/null
@@ -1,376 +0,0 @@
-#!/usr/bin/python2.7
-import sys
-import os
-import re
-import time
-import string
-import urllib, urllib2
-from subprocess import Popen, PIPE
-import sha
-import simplejson as json
-
-import mimetypes
-
-urlencode = urllib.urlencode
-urlopen = urllib2.urlopen
-Request = urllib2.Request
-
-MAX_SIZE = 1024 * 1024 * 1.2 * 1.5
-WORKING_DIR = "/var/www/cache"
-LIKE_A_BOSS = "ryz pepper seamonkey JAMES".split(" ")
-
-BIN_CONVERT = "/usr/bin/convert"
-BIN_COMPOSITE = "/usr/bin/composite"
-BIN_IDENTIFY = "/usr/bin/identify"
-DEFAULT_FINALFORMAT = "gif"
-DB_TAG = "pb";
-
-GRAVITY = "NorthWest North NorthEast West Center East SouthWest South SouthEast".split(" ")
-
-#{{{Utility functions
-def is_color(s):
-  if s == "":
-    return "transparent"
-  if re.match('(rgba?\([0-9]+,[0-9]+,[0-9]+\))|([a-zA-Z]+)|(\#[A-Ha-h0-9]+)', s):
-    return s.replace(' ', '');
-  else:
-    sys.stderr.write("Not a color: {}\n".format(s))
-    raise ValueError
-def bool_correct(s):
-    if re.match(r'^false$', s, re.IGNORECASE):
-        return False
-    elif re.match(r'^true$', s, re.IGNORECASE):
-        return True
-    else:
-        return s
-
-class dotdict(dict):
-    """dot.notation access to dictionary attributes"""
-    def __getattr__(self, attr):
-        return self.get(attr)
-    __setattr__= dict.__setitem__
-    __delattr__= dict.__delitem__
-
-def get_mimetype(f):
-    try: 
-        mimetype =  Popen(
-            [BIN_IDENTIFY, f], stdout=PIPE
-        ).communicate()[0].split(" ")[1].lower()
-        return mimetype
-    except Exception as e:
-        sys.stderr.write("IMGRID couldn't determine mimetype")
-        sys.stderr.write(str(e))
-        raise;
-
-def sanitize (str):
-    return re.sub(r'\W+', '', str)
-
-def now():
-    return int(time.time())
-
-def browser_request (url, data=None):
-    headers = {
-        'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
-        'Accept': '*/*',
-    }
-    try:
-        req = Request(url, data, headers)
-        response = urlopen(req)
-    except IOError, e:
-        if hasattr(e, 'code'):
-            sys.stderr.write( '%s - ERROR %s' % (url, e.code) )
-            raise;
-        return None
-    else:   
-        return response
-
-def download(url, destination, max_size=MAX_SIZE):
-    response = browser_request(url, None)
-    rawimg = response.read()
-    if len(rawimg) == 0:
-        sys.stderr.write("got zero-length file")
-        raise;
-    if len(rawimg) > max_size:
-        sys.stderr.write("file too big: max size {} KB / {} is {} KB".format(
-            str(MAX_SIZE/1024), 
-            destination, 
-            str(len(rawimg)/1024)
-        ))    
-        raise;
-    f = open(destination, "w")
-    f.write(rawimg)
-    f.close()
-
-def file_size (filepath):
-    try:
-        return os.stat(file)[6]
-    except Exception as e:
-        sys.stderr.write("IMGRID couldn't determine file size")
-        sys.stderr.write(str(e))
-        raise;
-
-def gif_frames(filepath):
-    try:
-        info = Popen([BIN_IDENTIFY,filepath], stdout=PIPE).communicate()[0]
-        frames = filter((lambda x: x), map(  
-            (lambda x: x.split(" ")[0]), 
-            (info).split('\n')
-        ))
-        return frames
-    except Exception as e:
-        sys.stderr.write("IMGRID couldn't get gif frames")
-        sys.stderr.write(str(e))
-        raise;
-#}}}
-
-class Photoblaster():
-    def __init__(self, params):
-        self.params = {}
-        self.tag = "im"
-        self.now = now()
-        self.files_created = []
-        self.commands = [];
-        self._required_keys = [
-#{{{ required_keys
-            "url",
-            "transparent",
-            "subtract",
-            "fuzz",
-            "width",
-            "height",
-            "black",
-            "white",
-            "brightness",
-            "contrast",
-            "saturation",
-            "hue",
-            "rotate",
-            "flip",
-            "flop",
-            "background",
-            "merge_early",
-            "compose",
-            "gravity",
-            "tile",
-            "format",
-            "name",
-            "callback",
-            "coalesce",
-            "nearest",
-            "dispose",
-#}}}
-        ]
-        for k in self._required_keys:
-            if k in params:
-                if k in [ 'url', 'background' ] and bool_correct(params[k]):
-                    self.params[k] = {}
-                    self.params[k]['url'] = params[k]
-                    self.params[k]['filename'] = "PBTMP{}_{}".format(now(), k)
-
-                    self.params[k]['path'] = os.path.join(WORKING_DIR, self.params[k]['filename']) 
-                    try:  
-                        download(self.params[k]['url'], self.params[k]['path'])
-                        self.files_created.append(self.params[k]['path'])
-                        self.params[k]['mimetype'] = get_mimetype(self.params[k]['path'])
-                        frames = gif_frames(self.params[k]['path'])
-                        if len(frames) > 1:
-                            self.params[k]['path'] = random.choice(frames) 
-                            
-
-                    except Exception as e:
-                        sys.stderr.write("BAD PARAMS\n")
-                        sys.stderr.write(str(e))
-                        raise;
-                elif k in [ 'black', 'white', 'subtract' ]:
-                    try:
-                      self.params[k] = is_color(params[k])
-                    except Exception as e:
-                      sys.stderr.write("Unable to process color for:\n")
-                      sys.stderr.write(k)
-                      raise e
-                else:
-                    self.params[k] = bool_correct(sanitize(params[k]))
-            else:
-                self.params[k] = False;    
-        
-        self.params = dotdict(self.params)
-
-        self.basename = self._get_filename();
-        
-        if not self.params.format:
-            self.params.format = DEFAULT_FINALFORMAT
-        self.filename = "{}.{}".format(self.basename, self.params.format)
-        #final filepath is stored in self.filepath
-        self.filepath = os.path.join(WORKING_DIR, self.filename) 
-
-    def _get_filename(self):
-        return "{}_{}_{}".format(
-            self.tag,
-            now(),
-            self.params.username or ""
-        );
-
-    def _call_cmd(self, cmd, error=""):
-        try:
-            call(cmd)
-            self.commands.append(" ".join(cmd)); 
-        except Exception as e:
-            sys.stderr.write("IT HIT AN ERROR")
-            sys.stderr.write(str(cmd))
-            if error:
-                sys.stderr.write(error)
-            else:
-                sys.stderr.write(str(e))
-
-    def _cleanup(self):
-        if not len(self.files_created):
-            pass
-        cmd = ["rm", "-f"] + self.files_created
-        self._call_cmd(cmd)
-
-def bin_composite (params, bottomdir, bottomfile, topdir, topfile, newfile):
-  cmd = [BIN_CONVERT]
-  cmd.append(os.path.join(bottomdir,bottomfile))
-  cmd.append('null:')
-  cmd.append(os.path.join(topdir,topfile))
-  cmd.append("-matte")
-  cmd.extend(params)
-  cmd.append("-layers composite")
-  cmd.append(os.path.join(topdir, newfile))
-#  g.write("bin_composite command: %s" % (" ".join(cmd)));
-  os.system(" ".join(cmd))
-  os.system("rm "+os.path.join(bottomdir,bottomfile)+" "+os.path.join(topdir,topfile))
-
-def bin_convert (directory, params, oldfile, newfile):
-  cmd = [BIN_CONVERT, os.path.join(directory, oldfile)]
-  for x in params:
-    cmd.append(x)
-  cmd.append(os.path.join(directory,newfile))
-  os.system(" ".join(cmd))
-#  g.write("bin_convert command: %s" % (" ".join(cmd)));
-  os.system("rm "+os.path.join(directory,oldfile))
-
-  def _build_cmd(self):
-    cmd = []
-    #FIXME test if number
-    if self.params.rotate: cmd += ["-rotate", self.params.rotate ]
-    if self.params.flip: cmd += ["-flip"]    
-    if self.params.flop: cmd += ["-flop"]    
-
-if param['transparent'] == "true":
-  tag = "transparent"
-  if is_number(param['fuzz']) and param['fuzz'] != 0:
-    cmd.append("-fuzz")
-    cmd.append(param['fuzz']+"%")
-  subtract_color = as_color(param['subtract'], "white")
-  cmd.append("-transparent")
-  cmd.append(subtract_color)
-
-VALID_DISPOSE_METHODS=["none","previous","background"]
-dispose = "None"
-
-if param['width'] is not None and is_number(param['width']):
-  if int(param['width']) > 1000 and NOT_A_BOSS:
-    error ("width cannot be greater than 1000")
-  width = param['width']
-if param['height'] is not None and is_number(param['height']):
-  if int(param['height']) > 1000 and NOT_A_BOSS:
-    error ("height cannot be greater than 1000")
-  height = param['height']
-
-if (width or height):
-  if param['nearest'] == "true":
-    if format == "gif":
-      cmd.append("-coalesce")
-      cmd.append("+map")
-    cmd.append("-interpolate")
-    cmd.append("Nearest")
-    cmd.append("-interpolative-resize")
-  else:
-    cmd.append("-resize")
-
-if width and height:
-  cmd.append(width + "x" + height)
-elif width:
-  cmd.append(width)
-elif height:
-  cmd.append("x" + height)
-
-if param['black'] != "black" or param['white'] != 'white':
-  try:
-    black = as_color(param['black'], "black")
-    white = as_color(param['white'], "white")
-    cmd.append("+level-colors")
-    cmd.append(black+","+white)
-  except ():
-    pass
-
-if param['contrast'] is not None and is_number(param['contrast']):
-  cmd.append("-contrast-stretch")
-  cmd.append(param['contrast'])
-  pass
-
-if param['brightness'] is not None or param['saturation'] is not None or param['hue'] is not None:
-  bstring = ''
-  if is_number(param['brightness']):
-    bstring += param['brightness']
-  else:
-    bstring += "100"
-  bstring += ','
-  if is_number(param['contrast']):
-    bstring += param['contrast']
-  else:
-    bstring += "100"
-  bstring += ','
-  if is_number(param['hue']):
-    bstring += param['hue']
-  if bstring != "100,100,":
-    cmd.append("-modulate")
-    cmd.append(bstring)
-
-if bgfile is not None:
-  tag = param['compose']
-  gravity = param['gravity']
-
-  if gravity not in GRAVITY:
-    gravity = 'center'
-
-
-  compositefile = "composite_" + newfile
-  compositeparams = ["-dispose", "None", "-gravity", gravity]
-  compositeparams.extend([ "-compose", param['compose'] ])
-
-  cmd.append( "-coalesce")
-  bin_convert (WORKING_DIR, cmd, oldfile, compositefile)
-  bin_composite (compositeparams, WORKING_DIR, bgfile, WORKING_DIR, compositefile, newfile)
-
-  insert_cmd(dir, oldfile, newfile, cmd, url, name, tag)
-
-else:
-  bin_convert(WORKING_DIR, cmd, oldfile, newfile)
-  insert_cmd(dir, oldfile, newfile, cmd, url, name, tag)
-
-# jsonp callback
-if param['callback'] is not None:
-  url = (BASE_URL+dir+"/"+newfile).replace("'", "\\'")
-  width, height = bin_identify (WORKING_DIR, newfile)
-  print param['callback'] + "({"
-  print "'url':'" + url + "',"
-  print "'size':" + str(file_size (WORKING_DIR, newfile)) + ","
-  print "'width':" + width + ","
-  print "'height':" + height
-  print "});"
-  moveToS3(os.path.join(WORKING_DIR, newfile), "im/"+dir+"/"+newfile)
-else:
-  print "#@im"
-  print ", ".join([k+"="+str(v) for k,v in param.iteritems()])
-  print " ".join(cmd)
-  print BASE_URL+dir+"/"+newfile
-  print file_size (WORKING_DIR, newfile)
-  print bin_identify (WORKING_DIR, newfile)
-  moveToS3(os.path.join(WORKING_DIR, newfile), "im/"+dir+"/"+newfile)
-
-#remove(newfile)
-
-g.close()
-