diff options
| -rw-r--r-- | Config/__init__.py (renamed from pb/Config/__init__.py) | 0 | ||||
| -rw-r--r-- | Db/__init__.py (renamed from pb/lib/Db/__init__.py) | 12 | ||||
| -rw-r--r-- | Db/sqlalchemy_example_code.py (renamed from pb/lib/Db/sqlalchemy_example_code.py) | 0 | ||||
| -rwxr-xr-x | Pb/Breaker/__init__.py (renamed from pb/Breaker/__init__.py) | 26 | ||||
| -rwxr-xr-x | Pb/Generate/__init__.py (renamed from pb/Generate/__init__.py) | 25 | ||||
| -rwxr-xr-x | Pb/Gradient/__init__.py (renamed from pb/Gradient/__init__.py) | 61 | ||||
| -rwxr-xr-x | Pb/Imgrid/__init__.py (renamed from pb/Imgrid/__init__.py) | 28 | ||||
| -rwxr-xr-x | Pb/Imlandscape/__init__.py (renamed from pb/Imlandscape/__init__.py) | 31 | ||||
| -rwxr-xr-x | Pb/Imlandscape/landscape (renamed from pb/Imlandscape/landscape) | 0 | ||||
| -rwxr-xr-x | Pb/Pattern/__init__.py (renamed from pb/Pattern/__init__.py) | 24 | ||||
| -rw-r--r-- | Pb/__init__.py | 143 | ||||
| -rw-r--r-- | pb/__init__.py | 0 | ||||
| -rw-r--r-- | pb/lib/Utils/__init__.py | 123 | ||||
| -rw-r--r-- | pb/lib/__init__.py | 0 | ||||
| -rw-r--r-- | pb/test/base64img | 1 | ||||
| -rw-r--r-- | pb/test/photo_data | 1 | ||||
| -rwxr-xr-x | pbserver.py | 22 |
17 files changed, 254 insertions, 243 deletions
diff --git a/pb/Config/__init__.py b/Config/__init__.py index b849b9e..b849b9e 100644 --- a/pb/Config/__init__.py +++ b/Config/__init__.py diff --git a/pb/lib/Db/__init__.py b/Db/__init__.py index ac7ca17..c42a7c5 100644 --- a/pb/lib/Db/__init__.py +++ b/Db/__init__.py @@ -5,7 +5,6 @@ USER = "asdfus" PASSWORD = "gTYgT&M6q" DATABASE = "asdfus" - from sqlalchemy import Column, Integer, LargeBinary, String, create_engine, sql from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker @@ -51,6 +50,17 @@ class Db(object): cmd=_NULL, dataobj=_NULL, tag=_NULL): + +# sys.stderr.write("date={}".format(str(date)) + "\n") +# sys.stderr.write("remote_addr={}".format(str(remote_addr)) + "\n") +# sys.stderr.write("name={}".format(str(username)) + "\n") +# sys.stderr.write("url={}".format(str(url)) + "\n") +# sys.stderr.write("dir={}".format(str(directory)) + "\n") +# sys.stderr.write("oldfile={}".format(str(oldfile)) + "\n") +# sys.stderr.write("newfile={}".format(str(newfile)) + "\n") +# sys.stderr.write("cmd={}".format(str(cmd)) + "\n") +# sys.stderr.write("dataobj={}".format(str(dataobj)) + "\n") +# sys.stderr.write("tag={}".format(str(tag)) + "\n") try: entry = ImCmd( date=date, diff --git a/pb/lib/Db/sqlalchemy_example_code.py b/Db/sqlalchemy_example_code.py index fc38b38..fc38b38 100644 --- a/pb/lib/Db/sqlalchemy_example_code.py +++ b/Db/sqlalchemy_example_code.py diff --git a/pb/Breaker/__init__.py b/Pb/Breaker/__init__.py index 9f5d31b..262ac4f 100755 --- a/pb/Breaker/__init__.py +++ b/Pb/Breaker/__init__.py @@ -3,9 +3,9 @@ import os import sys import random import re -import pb.lib.Utils as utils import urllib -from pb.Config import * +from Config import * +from Pb import Pb DEFAULT_FINALFORMAT = "png"; SUBTLE_BREAK_MARK = 'pron' @@ -27,7 +27,7 @@ HEADER_OFFSET = 2000 # 'STRIPES':'exr', # 'PHOTOCOPY':'art', -class Breaker(): +class Breaker(Pb): def __init__(self, **kwargs): self.params = {} self.tag = "imBreak" @@ -41,7 +41,7 @@ class Breaker(): "username", "expanded" ] - self.now = utils.now() + self._now = self.now() self.files_created = [] for k in self._required_keys: if k in kwargs: @@ -50,25 +50,25 @@ class Breaker(): elif k == 'url': self.params[k] = kwargs[k] else: - self.params[k] = utils.bool_correct(utils.sanitize(kwargs[k])) + self.params[k] = self.bool_correct(self.sanitize(kwargs[k])) else: self.params[k] = False; - self.params = utils.dotdict(self.params) + self.params = self.make_dotdict(self.params) self.basename, self._first_format = self._get_filename(); self._downloaded_file = os.path.join(WORKING_DIR, "IMBREAKTMP{}.{}".format(self.basename, self._first_format)) # same here try: - utils.download(self.params.url, self._downloaded_file) + self.download(self.params.url, self._downloaded_file) self.files_created.append(self._downloaded_file) except Exception as e: sys.stderr.write(str(e)) raise; - self._gif_frames = utils.gif_frames(self._downloaded_file) + self._gif_frames = self.gif_frames(self._downloaded_file) self._gif_frames = self._gif_frames if len(self._gif_frames) > 1 else False - self.width, self.height = utils.dimensions(self._downloaded_file) # same here + self.width, self.height = self.dimensions(self._downloaded_file) # same here if not self.params.finalformat: self.params.finalformat = DEFAULT_FINALFORMAT @@ -85,7 +85,7 @@ class Breaker(): def _call_cmd(self, cmd, error=""): try: - utils.call_cmd(cmd) + self.call_cmd(cmd) self.commands.append(" ".join(cmd)); except Exception: raise Exception("Unable to call cmd {}".format(str(cmd))) @@ -121,8 +121,8 @@ class Breaker(): name_part = url.split("/")[-1] try: parts = name_part.split(".") - name_part = utils.sanitize(parts[-2]) - file_format = utils.sanitize(parts[-1]) + name_part = self.sanitize(parts[-2]) + file_format = self.sanitize(parts[-1]) if not name_part or not file_format: sys.stderr.write( "Incompatible input file type") raise; @@ -134,7 +134,7 @@ class Breaker(): raise; if (len(name_part) > 20): name_part = name_part[:-20] - return "{}{}_{}_{}".format(self.tag, name_part, self.now, self.params.username or ""), file_format + return "{}{}_{}_{}".format(self.tag, name_part, self._now, self.params.username or ""), file_format #{{{#########rotatefunctions####################################### def _rotate(self): diff --git a/pb/Generate/__init__.py b/Pb/Generate/__init__.py index fbb74e3..385591e 100755 --- a/pb/Generate/__init__.py +++ b/Pb/Generate/__init__.py @@ -2,9 +2,8 @@ import sys import os -from pb.Config import * -import pb.lib.Utils as utils - +from Config import * +from Pb import Pb #FIXME these guys can do stuff wider than 1000 LIKE_A_BOSS = "ryz pepper seamonkey JAMES".split(" ") DEFAULT_FINALFORMAT = "gif" @@ -23,10 +22,10 @@ DISPOSE_DEFAULT = "None" def debuglog(s): sys.stderr.write(str(s) + "\n"); -class Generate(): +class Generate(Pb): def __init__(self, **kwargs): self.params = {} - self.now = utils.now() + self._now = self.now() self.files_created = [] self.commands = []; self._required_keys = [ @@ -79,22 +78,22 @@ class Generate(): 'path' : os.path.join(WORKING_DIR, self._make_tempname(k)) , } try: - utils.download(self.params[k]['url'], self.params[k]['path']) + self.download(self.params[k]['url'], self.params[k]['path']) self.files_created.append(self.params[k]['path']) - self.params[k]['mimetype'] = utils.get_mimetype(self.params[k]['path']) + self.params[k]['mimetype'] = self.get_mimetype(self.params[k]['path']) except Exception as e: sys.stderr.write(str(e)) raise Exception ("BAD PARAMS"); elif k in [ 'black', 'white', 'subtract' ]: try: - self.params[k] = utils.is_color(kwargs[k]) + self.params[k] = self.is_color(kwargs[k]) except Exception: raise Exception("Unable to process color for:\n{}".format(k)) elif k in [ "coalesce", "dispose", "nearest", "merge_early", "flip", "flop", "tile", "transparent", ]: - self.params[k] = utils.bool_correct(utils.sanitize(kwargs[k])) + self.params[k] = self.bool_correct(self.sanitize(kwargs[k])) elif k == 'gravity' and self._test_enum(kwargs[k], GRAVITY_PARAMS): self.params[k] = kwargs[k] elif k == 'format' and self._test_enum(kwargs[k], FORMAT_PARAMS): @@ -114,7 +113,7 @@ class Generate(): else: - self.params[k] = utils.sanitize(kwargs[k]) + self.params[k] = self.sanitize(kwargs[k]) if self.params.get('background'): self.tag = self.params.get('compose') @@ -126,7 +125,7 @@ class Generate(): self.filepath = os.path.join(WORKING_DIR, self.filename) def _make_tempname(self, s): - return "PBTMP{}{}".format(self.now, s); + return "PBTMP{}{}".format(self._now, s); def _test_enum(self, e, arr): if e in arr: return True @@ -135,13 +134,13 @@ class Generate(): def _get_filename(self): return "{}_{}_{}".format( self.tag, - self.now, + self._now, self.params.get('username',"") ); def _call_cmd(self, cmd): try: - utils.call_cmd(cmd) + self.call_cmd(cmd) self.commands.append(" ".join(cmd)); except Exception: raise Exception("Unable to call cmd {}".format(str(cmd))) diff --git a/pb/Gradient/__init__.py b/Pb/Gradient/__init__.py index aeb4d21..5120c7d 100755 --- a/pb/Gradient/__init__.py +++ b/Pb/Gradient/__init__.py @@ -6,9 +6,8 @@ import simplejson as json import sys
import os
import sha
-import pb.lib.Utils as utils
-from pb.Config import *
-
+from Config import *
+from Pb import Pb
PARAM_LIST = [
"width", "height",
@@ -45,31 +44,31 @@ HALFTONEVALUES = { }
-class Gradient:
+class Gradient(Pb):
def __init__(self, **kwargs):
self.tag = "imGradient"
self.directory = WORKING_DIR
self.commands = []
self.filename = ""
self.filepath = ""
- self.now = utils.now()
+ self._now = self.now()
params = {}
for key in PARAM_LIST:
if key in kwargs:
if key in ['color1', 'color2']:
- params[key] = utils.is_color(kwargs[key])
+ params[key] = self.is_color(kwargs[key])
else:
- params[key] = utils.sanitize(kwargs[key])
+ params[key] = self.sanitize(kwargs[key])
if key in ['rotate','tilt','blurriness','stripenumber','stripeintensity']:
- params[key] = params[key] if utils.is_number(params[key]) else ""
+ params[key] = params[key] if self.is_number(params[key]) else ""
elif key in ['brightness', 'contrast', 'hue']:
- if not utils.is_number(params[key]) or params[key] == "100": params[key] = ""
+ if not self.is_number(params[key]) or params[key] == "100": params[key] = ""
else:
params[key] = ""
- params['width'] = params['width'] if utils.is_number(params['width']) else DEFAULT_WIDTH
- params['height'] = params['height'] if utils.is_number(params['height']) else DEFAULT_HEIGHT
+ params['width'] = params['width'] if self.is_number(params['width']) else DEFAULT_WIDTH
+ params['height'] = params['height'] if self.is_number(params['height']) else DEFAULT_HEIGHT
params["color1"] = params["color1"] or DEFAULT_COLORS["color1"];
params["color2"] = params["color2"] or DEFAULT_COLORS["color2"];
self.params = params
@@ -84,31 +83,31 @@ class Gradient: self.tag,
self.params['color1'].replace('#','').replace('(','-').replace(')','-'),
self.params['color2'].replace('#','').replace('(','-').replace(')','-'),
- self.now,
+ self._now,
self.params['username'],
self.params['filetype'] or DEFAULT_FORMAT,
)
def _call_cmd(self, cmd):
try:
- utils.call_cmd(cmd)
+ self.call_cmd(cmd)
self.commands.append(" ".join(cmd));
except Exception:
raise Exception("Unable to call cmd {}".format(str(cmd)))
def _build_cmd(self):
- cmd = [BIN_CONVERT]
- cmd.extend([
+ self.cmd = [BIN_CONVERT]
+ self.cmd.extend([
'-size',
"{}x{}".format(self.params["width"],self.params["height"])
])
- if self.params['rotate']: cmd.extend(["-rotate", self.params["rotate"]])
- if self.params['tilt']: cmd.extend(["-distort","SRT",self.params['tilt']])
- if self.params['flip'] == "true": cmd.append("-flip")
- if self.params['flop'] == "true": cmd.append("-flop")
- if self.params['contrast']: cmd.extend(["-contrast-stretch", self.params['contrast']])
+ if self.params['rotate']: self.cmd.extend(["-rotate", self.params["rotate"]])
+ if self.params['tilt']: self.cmd.extend(["-distort","SRT",self.params['tilt']])
+ if self.params['flip'] == "true": self.cmd.append("-flip")
+ if self.params['flop'] == "true": self.cmd.append("-flop")
+ if self.params['contrast']: self.cmd.extend(["-contrast-stretch", self.params['contrast']])
gradients = {
"canvas" : ["canvas:{}".format(self.params['color1'])],
"radial" : [
@@ -135,33 +134,33 @@ class Gradient: "noise" : ["xc:","+noise","Random","-virtual-pixel","tile"]
}
if self.params["gradienttype"] in gradients:
- cmd.extend(gradients[self.params['gradienttype']])
+ self.cmd.extend(gradients[self.params['gradienttype']])
else:
- cmd.append("gradient:{}-{}".format(self.params['color1'], self.params['color2']))
+ self.cmd.append("gradient:{}-{}".format(self.params['color1'], self.params['color2']))
if self.params['blurriness']:
- cmd.extend(["-blur","0x{}".format(self.params["blurriness"]),"-auto-level"])
+ self.cmd.extend(["-blur","0x{}".format(self.params["blurriness"]),"-auto-level"])
if self.params['stripes'] == "true" and len(self.params['stripenumber']):
- cmd.extend(["-function","Sinusoid"])
+ self.cmd.extend(["-function","Sinusoid"])
if self.params['stripeintensity']:
- cmd.append("{},{}".format(self.params['stripenumber'],self.params["stripeintensity"]))
+ self.cmd.append("{},{}".format(self.params['stripenumber'],self.params["stripeintensity"]))
else:
- cmd.append(self.params['stripenumber'])
+ self.cmd.append(self.params['stripenumber'])
if self.params["halftone"] in HALFTONEVALUES:
- cmd.extend([
+ self.cmd.extend([
"-ordered-dither",
HALFTONEVALUES[self.params["halftone"]]
])
- cmd += [
+ self.cmd += [
'-modulate',
"{},{},{}".format(
self.params['brightness'] or "100",
self.params['saturation'] or "100",
self.params['hue'] or "100")
]
- cmd.append(os.path.join(self.directory,self.filename));
- self._call_cmd(cmd)
+ self.cmd.append(os.path.join(self.directory,self.filename));
+ self._call_cmd(self.cmd)
def _get_bevelvalue(self):
w, h = map(int, (self.params['width'], self.params['height']))
@@ -189,6 +188,8 @@ class Gradient: self.filename = self.newfilename()
self.filepath = os.path.join(self.directory, self.filename)
self._build_cmd()
+# sys.stderr.write(str(self.cmd))
+
if self.params['bevel'] in self._bevelvalues:
self._make_bevel()
diff --git a/pb/Imgrid/__init__.py b/Pb/Imgrid/__init__.py index 70da965..52cb748 100755 --- a/pb/Imgrid/__init__.py +++ b/Pb/Imgrid/__init__.py @@ -4,15 +4,15 @@ import re import os import simplejson as json import random -import pb.lib.Utils as utils -from pb.Config import * +from Config import * import tempfile +from Pb import Pb DEFAULT_HEIGHT = 400 DEFAULT_WIDTH = 600 DEFAULT_LINE_COLOR = "silver" -class Imgrid(): +class Imgrid(Pb): def __init__(self, **kwargs): self.tag = "imGrid" self.files_created = [] @@ -44,7 +44,7 @@ class Imgrid(): "username" #}}} ] - self.now = utils.now() + self._now = self.now() #Work out params ... #note, tmpfile lib is pretty much useless here, given imagemagick's behavior with gifs (it splits them) etc... @@ -52,17 +52,17 @@ class Imgrid(): self.params = {} for k in self._required_keys: if k in kwargs: - if k in [ 'bgimage', 'planebgimage', 'imageinstead' ] and utils.bool_correct(kwargs[k]): + if k in [ 'bgimage', 'planebgimage', 'imageinstead' ] and self.bool_correct(kwargs[k]): self.params[k] = { 'url' : kwargs[k], 'filename' : self._make_tempname(k), 'path' : os.path.join(WORKING_DIR, self._make_tempname(k)) , } try: - utils.download(self.params[k]['url'], self.params[k]['path']) + self.download(self.params[k]['url'], self.params[k]['path']) self.files_created.append(self.params[k]['path']) - self.params[k]['mimetype'] = utils.get_mimetype(self.params[k]['path']) - frames = utils.gif_frames(self.params[k]['path']) + self.params[k]['mimetype'] = self.get_mimetype(self.params[k]['path']) + frames = self.gif_frames(self.params[k]['path']) if len(frames) > 1: self.params[k]['path'] = random.choice(frames) @@ -71,7 +71,7 @@ class Imgrid(): raise Exception ("BAD PARAMS"); elif k in [ 'skycolor', 'bgcolor', 'planebgcolor','linecolor' ]: try: - self.params[k] = utils.is_color(kwargs[k]) + self.params[k] = self.is_color(kwargs[k]) except Exception: sys.stderr.write(kwargs[k] + "\n") raise Exception("Unable to process color for:\n{}".format(k)) @@ -80,11 +80,11 @@ class Imgrid(): elif k == 'zoom': self.params[k] = int(float(kwargs[k])) else: - self.params[k] = utils.bool_correct(utils.sanitize(kwargs[k])) + self.params[k] = self.bool_correct(self.sanitize(kwargs[k])) else: self.params[k] = None; - self.params = utils.dotdict(self.params) + self.params = self.make_dotdict(self.params) self.basename = self._get_filename(); @@ -97,19 +97,19 @@ class Imgrid(): def _get_filename(self): return "{}_{}_{}".format( self.tag, - self.now, + self._now, self.params.username or "" ); def _call_cmd(self, cmd): try: - utils.call_cmd(cmd) + self.call_cmd(cmd) self.commands.append(" ".join(cmd)); except Exception: raise Exception("Unable to call cmd {}".format(str(cmd))) def _make_tempname(self, s): - return "IMGRIDTMP{}{}".format(self.now, s); + return "IMGRIDTMP{}{}".format(self._now, s); #makes a canvas file...step 1 (if not bgimage) diff --git a/pb/Imlandscape/__init__.py b/Pb/Imlandscape/__init__.py index 156dac1..59212a6 100755 --- a/pb/Imlandscape/__init__.py +++ b/Pb/Imlandscape/__init__.py @@ -1,24 +1,22 @@ #!/usr/bin/python2.7 -import os import sys import random import re -import pb.lib.Utils as utils import urllib import urlparse -from pb.Config import * - +from Config import * +import Pb import base64 import time import string -import urllib from subprocess import Popen, PIPE import sha import simplejson as json +from Pb import Pb import mimetypes -class Imlandscape(object): +class Imlandscape(Pb): def __init__(self, **kwargs): sys.stderr.write("inside init"); sys.stderr.write(str(kwargs)) @@ -32,13 +30,13 @@ class Imlandscape(object): "texture", "name", ] - self.now = utils.now() + self._now = self.now() self.files_created = [] for k in self._required_keys: if k in kwargs: self.params[k] = kwargs[k] else: - self.params[k] = utils.bool_correct(utils.sanitize(kwargs[k])) + self.params[k] = self.bool_correct(self.sanitize(kwargs[k])) def _filename_from_url (self, url, name=""): if "?" in url: @@ -52,7 +50,7 @@ class Imlandscape(object): filename = "" if name != "": name = name+"_" - return "{}_{}{}_{}.{}".format("imlandscape", name, filename,self.now, "png") + return "{}_{}{}_{}.{}".format("imlandscape", name, filename,self._now, "png") def _saveImgData(self, imgdata, filename): try: @@ -87,18 +85,3 @@ class Imlandscape(object): self.filepath = self._filename_from_url(self.params.get('texture',""), self.params.get('name',"")); self._saveImgData(self.params.get('imgdata'), self.filepath); -if __name__ == "__main__": - f = open("/tmp/base64img") - data = f.read() - f.close() - TEST_PARAMS = { - "heightmap" : "https%3A%2F%2Fwww.google.com%2Fimages%2Fsrpr%2Flogo11w.png" , - "imgdata" : data, - "texture" : "https%3A%2F%2Fwww.google.com%2Fimages%2Fsrpr%2Flogo11w.png", - "name" : "pepper", - } - b = Imlandscape(**TEST_PARAMS) - b.create(); - print b.filepath - - diff --git a/pb/Imlandscape/landscape b/Pb/Imlandscape/landscape index 10e8ede..10e8ede 100755 --- a/pb/Imlandscape/landscape +++ b/Pb/Imlandscape/landscape diff --git a/pb/Pattern/__init__.py b/Pb/Pattern/__init__.py index b1fb9af..905ddf9 100755 --- a/pb/Pattern/__init__.py +++ b/Pb/Pattern/__init__.py @@ -4,8 +4,8 @@ import sys import random import re import urllib -from pb.Config import * -import pb.lib.Utils as utils +from Config import * +from Pb import Pb import simplejson as json from PIL import Image @@ -13,13 +13,13 @@ import uuid FUSE_MODE="Pin_Light" -class Pattern: +class Pattern(Pb): def __init__(self, **kwargs): self.params = {} self.tag = "imPattern"; self._pid = str(os.getpid()) self.commands = []; - self.now = utils.now() + self._now = self.now() self.height = "" self.width = "" self._required_keys = [ @@ -38,14 +38,14 @@ class Pattern: elif k == 'pattern_data': self.params[k] = kwargs[k] #FIXME add conversion data else: - self.params[k] = utils.sanitize(kwargs[k]) + self.params[k] = self.sanitize(kwargs[k]) else: self.params[k] = False; if not self.params['image_url']: sys.stderr.write('no image url'); raise ValueError - self.params = utils.dotdict(self.params) + self.params = self.make_dotdict(self.params) self.basename, self._format = self._get_filename(); #FIXME omit file extension for downloaded files @@ -55,7 +55,7 @@ class Pattern: self._download(self.params.image_url, self._downloaded_file) - self.width, self.height = utils.dimensions(self._downloaded_file) # same here + self.width, self.height = self.dimensions(self._downloaded_file) # same here self.filename = "{}.{}".format(self.basename, self._format) self.filepath = os.path.join(WORKING_DIR, self.filename) @@ -70,7 +70,7 @@ class Pattern: def _download(self, url, dest): try: - utils.download(url, dest) + self.download(url, dest) self.files_created.append(dest) except Exception as e: sys.stderr.write(str(e)) @@ -78,7 +78,7 @@ class Pattern: def _call_cmd(self, cmd): try: - utils.call_cmd(cmd) + self.call_cmd(cmd) self.commands.append(" ".join(cmd)); except Exception: raise Exception("Unable to call cmd {}".format(str(cmd))) @@ -113,8 +113,8 @@ class Pattern: name_part = url.split("/")[-1] try: parts = name_part.split(".") - name_part = utils.sanitize(parts[-2]) - file_format = utils.sanitize(parts[-1]) + name_part = self.sanitize(parts[-2]) + file_format = self.sanitize(parts[-1]) if not name_part or not file_format: sys.stderr.write( "Incompatible input file type") raise; @@ -126,7 +126,7 @@ class Pattern: raise; if (len(name_part) > 20): name_part = name_part[:-20] - return "{}{}_{}_{}".format(self.tag, name_part, self.now, self.params.username or ""), file_format + return "{}{}_{}_{}".format(self.tag, name_part, self._now, self.params.username or ""), file_format def _cleanup(self): cmd = ["rm"]+self.files_created diff --git a/Pb/__init__.py b/Pb/__init__.py new file mode 100644 index 0000000..f584f00 --- /dev/null +++ b/Pb/__init__.py @@ -0,0 +1,143 @@ +import re +from Config import * +import time +import urllib +import urllib2 +import sys +import os +from subprocess import Popen,PIPE,call +Request = urllib2.Request +urlencode = urllib.urlencode +urlopen = urllib2.urlopen + + +class Pb(object): + def __init__(self): + pass; + + @staticmethod + def call_cmd(cmd, error=""): + try: + call(cmd) + except Exception as e: + raise (str(e)) + + @staticmethod + 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 + + @staticmethod + def dimensions (filepath): + #works in lieu of a mimetype check (it reads the header as well) + ident = (Popen([BIN_IDENTIFY, filepath], stdout=PIPE).communicate()[0]).split(" ") + return ident[2].split("x") + + @staticmethod + def is_number(s): + try: + return int(s) + except (ValueError, TypeError): + return False + + @staticmethod + 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 + + @staticmethod + 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("couldn't determine mimetype") + sys.stderr.write(str(e)) + raise; + + @staticmethod + def sanitize (s): + return re.sub(r'\W+', '', s) + + @staticmethod + def now(): + return int(time.time()) + + @staticmethod + 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(self, url, destination, max_size=MAX_SIZE): + response = self.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() + + @staticmethod + def file_size (filepath): + try: + return os.stat(filepath)[6] + except Exception as e: + sys.stderr.write("Couldn't determine filesize\n") + sys.stderr.write(str(e)+"\n") + raise; + + def gif_frames(self, 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("{} couldn't get gif frames".format(self.__class__.__name__)) + sys.stderr.write(str(e)) + raise; + + @staticmethod + def make_dotdict(d): + return dotdict(d) + +class dotdict(dict): + """dot.notation access to dictionary attributes""" + def __getattr__(self, attr): + return self.get(attr) + __setattr__= dict.__setitem__ + __delattr__= dict.__delitem__ + diff --git a/pb/__init__.py b/pb/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/pb/__init__.py +++ /dev/null diff --git a/pb/lib/Utils/__init__.py b/pb/lib/Utils/__init__.py deleted file mode 100644 index 1d5a708..0000000 --- a/pb/lib/Utils/__init__.py +++ /dev/null @@ -1,123 +0,0 @@ -import re -from pb.Config import * -import time -import urllib -import urllib2 -import sys -import os -from subprocess import Popen,PIPE,call -Request = urllib2.Request -urlencode = urllib.urlencode -urlopen = urllib2.urlopen - -def call_cmd(cmd, error=""): - try: - call(cmd) - except Exception as e: - raise (str(e)) - -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 dimensions (filepath): - #works in lieu of a mimetype check (it reads the header as well) - ident = (Popen([BIN_IDENTIFY, filepath], stdout=PIPE).communicate()[0]).split(" ") - return ident[2].split("x") - -def is_number(s): - try: - return int(s) - except (ValueError, TypeError): - return False - -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("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(filepath)[6] - except Exception as e: - sys.stderr.write("Couldn't determine filesize\n") - sys.stderr.write(str(e)+"\n") - 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; diff --git a/pb/lib/__init__.py b/pb/lib/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/pb/lib/__init__.py +++ /dev/null diff --git a/pb/test/base64img b/pb/test/base64img deleted file mode 100644 index 81bb894..0000000 --- a/pb/test/base64img +++ /dev/null @@ -1 +0,0 @@ -data:image/png;base64,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
\ No newline at end of file diff --git a/pb/test/photo_data b/pb/test/photo_data deleted file mode 100644 index 461554b..0000000 --- a/pb/test/photo_data +++ /dev/null @@ -1 +0,0 @@ -data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAAb0AAAHVCAYAAABliSVzAAAgAElEQVR4Xuy9CYwkWXrf915EHpV131VdVX1fc%2BzMHrMUuSINLSAJkg3BhmGsYQg2TRCEAEuGBUGiIcgGaFKyDosmZS5lSTQpyLzh4bFLcjni7iw53Htnt2dmZ7Znunt6uuuuzMrK%2B86MiOf%2FF5FZldXT3VXV3VWV1fHPRnRkZuUR7%2Fdexj%2B%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%2BfP19p7KUr9bTDeXU66q1uqocHFHrKI%2BKoneUtPldJEACJBBCAr%2F9j0Y%2BMTxgzYwMmsmpUWt8eswesLTacFyVenfZKb11x6tcv1OvLKasyjvv1ar4m6lGldPXp5wZCOM1pVxgM13ouu8fiChF70C4%2BGISIAESIIH9EjCvTm2Lk8E9DTHz%2F8nev%2BmWMqapLN2QPV7TrDZMrlY3uWoTW0Plak2TsZRaU55ZM7a9ql21fitlFVYLafebq74Yui%2B%2FrLx7RPGBh0jR22%2Fv8XUkQAIkQAIHItAtegd6YyCITRh3FdwpQyIrEEq5v4UtiedTeC6pLJVc31SVpc1W5c6mqWwkvfJizilVsnYjoypOKa%2Bc7IZqvZ1SDbxPXKn4GN5IgARIgARI4AkSeDyxO9CBiMUIK8%2FA4tNi7blQtSYEcQWW4woer8C8XK63vPXvL7n59z5w8hS9A%2FHli0mABEiABB5GIBC8R55yexy4Hddp29Xpi2AZWwHHgw17o4oUvcdBzPeSAAmQAAlsE9ix8I5F9PbVExS9fWHii0iABEiABPYi8FDRk0iWHrhR9HqgE3gIJEACJPA0ENgRPfEs3nPrDc1jIMvTMNDYBhIgARLoBQKB6N1H8HpIAGnp9cJI4TGQAAmQwFNAwLw68RB77gF%2FOmILkKL3FAw0NoEESIAEeoHAg0XvAMp2gJc%2BSpspeo9C7fjfI%2F3W6Tv%2F%2FvPPK2uhT01cOhcbv3rGGn%2F2dHT88rw9cXZGTyrLzOIl2NQpeB5O4Z1yf%2BRImtE1gPWncxxvRwKdX0ICR09gx7W5D%2Ffmfg%2FvEASQJ6H9wj%2F%2B11nnzqnYpQkVf%2FbCYOz8hBu7NG9ik5PW6GDcPtPfp8%2F0x%2FXZ%2FoQ6k4ips7EoxE6pGAQuhtyUGEQvjmRNeWwfWVMOYcA%2B5Njl29qJqp29lnyhIp7fUEZLFYckElXXZV8s6Uwq7%2BaTeZPfzJn8etotZJO1%2FHWlmmN3lLk1pMxrr%2B36vCPDxi8igZNIYMfKe4Ki1w3iCZ1PKHq9M7psWGt2X05F%2Bs4reyqq7OkhFZmb6hueHbHGZ8b1%2BPSkHp%2BbsMdmx9R4X8wXtSmcwLHX2Pv3sem%2BY23SExqYB2qD8asw1PCemr83pg6Rq7lGoZ67Wqo1vcVawyw1WtZSqaIWS04sdSud9jYWlXe9orx0WnkQOPmlHtKv9UCt4YtJ4EQSOHTRu5fKI55rKHrHN7yEvf3DP6wSL0wPJp494%2FZdmYsknjnvJc5Nx4aUds%2FgxH0GrzkN6wR7cxp2x1mc1FF71bfWLP%2B%2Bwf1gf7R9%2BYgD7hBw1%2FGZsN70mtJmHYKHTa83XbNxJ2kKd1ZN8YM1U7iVdIvvr9YLw99UhZd3ykV0WtE7rTkEQPxIEjgKAkcueo9oBR7tifIoyPfWd1if%2FrSyrpTgW5xW1vlBZV1%2BXmkr0jc1MGhNjwxGpof7DfYKez0djahxnLxH0QTZZM4tuK%2FVAPbBPJ6Im%2Fzr3Jf2HkUvHq8sSKFYETdYcH7h2DoEru64upwtemvZklnLls1arqjWMkV3rVQwaxs53UhnrGYatdo3C6q51lCtxUXU5KM111u%2FEB7NU0Hg0QXvkE4sD%2FnYozhdPhWdut9GXLqk4pcx7%2FaxM4Px58%2B78fmz0b4XT3vx8SE9pixrDpbIPCw37NU8tjnYaKeCOTfMtymNbdd9ser2dztoTx7SWNvfwR7oVVW8Oru9adz3VK7hqOzNJW%2FzvRVv88aSs%2FneMu4vtzbfvq1SeO2RLkp5oNbwxSTwFBJ4QqInqykUcBGPi1wTD%2BIQFPaqr%2B3hOhi5B5zjDnqqPNiXhuTVU1Nq8IUFRE4uRCeeOW1NXj1tTVw9Y09cnLfG0Vnj6LidvVJjwAILTg%2B2bTS4Jo3lOyu9tqvyaGy33ukdabmUihW3o9yXR1qKxZocnltruy7XxG2pjLfmuNb6zVWv%2Bu6iV1nccCo37tiVN9LV6ltv%2BUuPUPB6p2d5JCEh8Giit0uV5EEWv%2FwcvDj5tvgVcS7ow1p7I3jc8XqN4XyZeBysFL296UUuYQ6tNKMi54aUbcVVZDSm7JGRvoGpUXd6ZsKaOTWhpxFgMj07oWZOT%2BupiRFrAp3U728am4J70mAL3JTHG2iyd3uP8hUiclhE0l%2FnqrNBtLTjeSbVcsyi46nFlquXHM%2Fc9RreUqQ%2Fvvj2Xdu7TyDKvSsrH2U7%2BF0kEFoCu3PzDhIL1i16CD5TOuOLnhLhw7p5RmFiSJUcx5QzBc%2BzbTUZsfV0JKKmoraejUfVNF4r3jCJaejEOAT7h9woeveBg9SAvlMDqv%2FsnMLkWzwxP2X65qci8ekJ0zcU1%2BOYe5uJxfR0QrY%2BNd0ft2YG%2B8w00gSG0XERWCjYVATwo4HrEvsg%2BIS3HQIyNyfLfpTADHuDvTw2pWxRpZFGkEzmvWQqozZwP7WexuNkPRkrKfcaXjiElIIppBS0g1I66QrkSwIkcMQEnoDoyQWvnAsy%2BP1jE4tPb2KPpYBMKVdR5bWMU72TVHmIXxORezA41KnJEevU1Ig%2BNTWq5wb6EAsh6VkeXKJapop8t6hscu7ddQuj6HUSu%2FVngCL9aaVLuJ544bQamO3vG58ed8dPjdsjM2MamzUyN6GGRwdgXmtxS2JeTkmwib9NwAU3gb2kDoSR4%2BP8tCR3Lu1fzXnYtAx2bEZl1zNe7va6yb%2B%2F5m%2B5xWU3d2e5mfvOoj%2BvJ4EovJEACfQQgQOKXmfNO7TA%2BOdiLL6QxVaAjZi3MaWhtcq5nl63LXnOFFZSbnUtbarfve2urGd1o1BymumiapVrujkYN4MX5%2FX81QV7%2FsqChc2enx6VFC5MHxkziHOLbOJpk%2Bkk2UJxsvbBShTlVFpZs2eUlijKAURRXhGzeDg%2B25ewZvpjarYvbst%2BZiChpnHlMB2LiOUG%2F7HW8CFjbzRclQAp7kq6KR%2F1ZycCt9FOEsccnZKE8Q10ESw6p3B33au%2Bv6arH6w71aV1u3JjrVZJX1eV28qP2uSNBEigxwjsQ%2FS6%2FZiYhjAya99RH%2B0Ztey4Bg5MlYf45RstswplKkRtq1CpmfL6llN%2B%2FaY3%2F9Yd9z%2BupXU1l29UIHrNzZpqZbNKLqDlFv34JTX67Pn46OVT1tizZ6zRZ%2Bb16DPn7NE43KGQ1ilYgTP43Kmn1kL5NNyLjU%2Bp6IVRFb08pyLPTQ%2Fas9Ne5MIZY8%2BPR%2FuU7c0r11oI8t%2BQB6cNNuTEGSW5cUEeXPfWyYfrsQF3og5Hw7ozagnHvATW2OtF8F9U2lvMFL3s7aTl3LxjORuZknN9UTlbd5Tzym1%2Frk%2Fm63gjARLoQQI7onffWYZ7YigNvDX%2BiubB5J9RK03HK7dcVXBcVXQ9UyhX1ZLWpgiLr5TKeZVU1lR%2B68vujWxe11eL9dpGUVVRUEKiuh82gegX%2B%2FjhCyrykXMqMjsxHLl6wYu8OOtFnjbRsz92Tg2dPaOGLkzFhi%2FP2UPn5rzhSwvW0IW5yBDM5UlADqqXaN8tKffbzxkJMNnJgbs3J64HB9uTP6THHg4IQjEOLLcWhmMQmKINAlW0U2uqZLluVnDltlKpquVy01vJF9VKxdErW61qYQPVUTIpZRqbymMJsCffs%2FxEEjgsAvsWvSBCGzm2chFr%2FMAziNytRksVm01VQkGJYqupsvmKWsHz5VoLASx5r%2Fbdm97wF1%2BvfzlTVo2co%2BqplF996SARM9J0OblJ3jS09OTf7GfPqumLM9Hps%2FNm%2BsKsNXNp3p4%2BP6dmLpyyxE0poa4dlyT2kirguyhluzeS8mngcRw9igGsceVlsGFvsLd0xd9rXU1mvBR88snVLZPcyKjkaqqVXMnbyXSmkRw8gzQDRKOwSspxdBu%2FkwQej8A%2BXZuB3Ek6khILDRfGQelAD67MN2sNVaq3sDVNKY8iE8WqmzGehftePV106%2F%2F35xtvYXKvCWFsrq760xwHFbxdjezlk7xfbguRlPZwTdkJpAtMJpAyMKHsQVvZpyajs9PD1uz0mA62ETU7NWrNTuH%2BQJ%2Bf09FJbEQ0j190OYjm0f6etydHQCqlSF5NEVZdASMbmx91VXCMVbi74WburKkM8um2bq17maUNK3M71cx875YfvCLv5Y0ESOCEEthD9AJ%2F546DE54fP0LbT0sSQ69cM9%2Bo1FVZ5u5g8ZWWUu4HjYZXabiYuyt6jffWTOQ3v9L4OtyZkn8r22MJnmDuNdGLvDSnYglUNDk9rWIXphKxiXEvvjBtYjPjkfhgVE%2F39alTsSiCTqLqVFyCT2La38dsRFPKXJyfo6GxGQQCtetUBnkbvdbWEzrMdx12Ho8yEDtEXlpBBKaEHCMas1ZXucUN1L7EhuCUIsSvsJSyC4ub9eK1WxBFJpE%2FDf3PNoScwJ6iJ5InxRODG8oImgq8P5jXk7k9zNsXzJ9VaqqMqY9KvuTmFlPeUrVlVetVt56v6Oa%2F%2F9Xam4vBnL5sjy14PSF6SPyOTz2vBs5OqIHz87GBuVmEoJ6yBy7OWgPnsMVi%2FpybJCHK%2FNu0fz%2BYj%2Bs8F%2FJhdwzNF9eEQrkvC5tRmxjEwV55KfRNKlcxueWkVVlcc6t3Nt3qyoZVublcr97Kqert237VFAamHEO38StJ4EkTeIjodVITAsEL3JtSYkymPySYpVGtm1fzFVPNl0y1VDPV1bS3tpZxNyt1XYcQtrIIbfk3X2i91Ra7J1Y48Visn5kZNXBmSo1fmIqOn50y4%2BdPWeNnsZ2b1WPnpq2JRB%2Fy4pSSdAHkxyFtQJthaHxwX%2BH%2BU5vofSzdcb%2FfQXvAIoA4GKydEmGm1dSVUt2sl2tqo1z1NopVtYEBul6sq%2FU6ntssu8U8CjxvZaxGqlJvJnPwxZdUI%2BWoJgs%2BP%2BlTDj%2BPBI6XwEOCWLpFrxPWKZ4gBKFoTGuYRqZovpApqWqx5FQLVav6%2FQ%2Bad1MFq9hoOU3k4Dm%2F9MfNdw6jdUd2lh0dVaMXp9Xs%2BbnI7LkZa%2FbsrD51bgaPZ%2B1ZrO59arBfo8YGIiiDObe%2B9hzczuOnVugOo1sf%2BTNlcIoLoasGZrsuJmph5kre1kbWrCazajWZ81ZRLWU1mTErGzmztpZqrdYcVWvWlFuOKg8J%2Fy6sdA9CJ5%2FXcU08sau1R24h30gCJPDECDxU9DrnksDSk8AVKQYP0YPwGd1YSju%2FCyuvlivq2kbGyX%2FrhrNYq%2Bl6C68t1bX7u19pvP%2FEDrTrgx5X9CSfzV5YQC3KhrJrCDaZQbCJtlXExiKos%2F2xsakxb2Z23DqFCiczqE05i7Ixs3g8g%2BCTUwg4wbpxKNdl%2FFIxUrZr537wmKW7DqPX72%2FbBX7z7XBiHdw3vui5d1NmZTllVpdS3srihlpZTDqrd9N6ZXHNWV1MqpW2sB3V0fJ7SIAEeoDAPkVPLnYlnWkDYif5dRLBWb%2Bx4vzWZt7UcyVdv7XqJN%2B%2BbZLlhnKqjvY8t%2B6%2Bek0tH0YTDyx6MgensHzOqSEVH4yp%2BMRovG9q0MQnh018YsTEhwbtscE%2BPYUaldMDA2pKKpsM9qupQdSoxDYVj4mLsivxW4JMdlYX6CSE793WAx%2F53h8Z0leI2EnRZ5lYbkHoZN%2BE1S0RVs1a01SWkmZjadOsLyW9dew3MNm8vrppbSyvtzYW06iowhsJkEAoCTxA9Doene4i8CJ2sshzBWf8SipnfmNp06mkkXC%2BVfAaX3%2FXWfxguZmXBLxIU3lffQ9Vmw7pth%2Fp0M9PoS4l5uFmZvsGTs94A%2FPjZuDctN2%2FMGMNnp6x%2Bvuj3pil1YTRehKZfxNy37LUBDK9Jy1tsIdFJ7fg23a%2BU%2B496orf%2BznyQ4L21HysLMiq%2FUTPYIHW7c33udczBZNfSXmby5sqtZg2qeUNk5LHHySdzXRKpZYLfkV03kiABEJIYHcQy65qLJ0HwVSJv8kyYVJu0C8sXbmx1Pp%2FUlndTELwbq15ha%2B%2BVVtZqqimCEUFGb43kOZ0WEgfJB2RK3NqdOGUGjk7GR05O2dGT09YI2dmrNFzM3pkYUqP9sV9iw3rHElgiRRkbu87ASiohH1YB83kg8ckG%2FjX5corSCD3E8v9x8Fz%2BNvapsmubHlbKymTXkqZzMqmt7W4qbeW11pbaxW1hbwZGby8kQAJhJTAPiI3O5aeCN86hE%2FKEPrLBV27af7N2pbbWs24jTduept%2F8EbD9xiNwwi6uSUrrxzerVv0%2Bl6cV5Mzc9HJc9Nm8vSsNXlmUk%2FI%2BnBnpvXEmWlrMhZDJZOg6DI2FGH214trF2LW8twRrxX3VBSUObzOvfm39C0AACAASURBVP8n%2B9FTWKEYbgbZawPx2nmMNexKq2mVXUmbLObwsnBpZhc3vezKppVdTDZzN1f81Q6YVH7U3cbvI4EeI7CP%2BbxgcWh%2FJXR1F5ssEisFoot%2Fes35xbWs21xJOs3Pv95ce%2F2Gn7trncO2eMjnF%2F3RC%2BrK%2FGxk9syEmV2YxCIEM3oWAje7gEjL09hjpQFZYUACTbo2jXXi8JysF3ef9Yp6rG%2F2PpxedJU%2B%2BThHuBo0rrJMERcuuJKS9ev8vQxCubIqIv2guLoJl%2BaW79bML6W9%2FPqWzq8lW%2Fm7WMvq1joqrwSLvfJGAiQQcgJ7iF53xLYko98ALjl%2FSNWm93%2F3q83fXkm3Wt%2B9a5d%2B45WaWHlyXgkmvA75pv%2Fffxj7GZTumplFCa%2FpMTU7izJeWKFW0gb8yExR3wfc70WpODiuXmnF4Xa1WGZBiTC%2FVJiUCcMVF9awCsqGmQIqIxSX0qYIsSsub%2Bni%2BqZbXExaxbV0s7i%2Brgp3cv4V2uEe5cF7j%2B8gARI4JgIPCWKR84REfgepT8G0yXWce3J4VPjKm94%2F%2FmCj6S5ntPONt2qZL77tF6w4spvOfK7%2Fe1g%2FbgpLr4u7Ekuti8%2FQdC%2FB7lenDv728GXYj%2Byon%2BQXHZfoHZ18yNWVBJxg8yeTpU6m3M%2Bjr3NYyyq3kfHKy5vY0rqylnbLyymrvLTRrGAJj%2FKdlKpw%2Fu5JDjh%2BFgk8HQQeKHo7Ls2dpHRj3sO5JwsNyf32q7V%2FvrxpNa8vVRvXkqp0%2FfrRLg6tzZ%2F2I1EQh7ITWSn37rc9HT0VnlZINXKJgMIcHAabQU1MS1YnN3iMOpnaZJstU1jd1LXltFffzOraUsqppTK6upFr1lZQMuzGqqrtY92q8BBlS0mABLYJPFT0%2FGXF2oUulEEer76JC20RvexnP9f4ueVVu3lrs1z7g6%2F7Vt4Tqam5364R0bvfFx6X%2FbPf4%2BbrHk5ArLuttugFRaCNhQHnF4POKs9kG47Or2a8xmYaCzNuOY3VrK5vbOl6Kt2or5VVPb2k6m%2Bn%2FIAV1snkaCMBEvgQgT0sPVkRQSw9WUbofVxwS3WVjPK87E%2F%2FhvOLd1Yqra98oCqo2HTkQXEiekfnaOPAOQoCYtVtwXW5hcEmIgfxw2Nl4TkRP7XltLzcak43N3JOYz2tm6mkbiyXrWZqudZMZ1Qjie3aur9uFQXvKHqM30ECJ4zAbsGTg9%2BWkaCUofEXkxaDSnKBv4fHi3Ih%2Ftuv1n%2FxGx9EKreXy41Xvu3P9R15YBxF74QNtj0OV9yXEDeFfBiInm%2Ft4TGEDisRYo%2F7rslsZHRzMe20UA2huZbVLeTfNTfStSYWeG3cSPkLNUpVFgre0zU22BoSeGIEHiJ6InSyiZgFQSxafQP7NTn%2F%2FOS%2Fdn5xvVlu3XzTv7CWwhhHbnRp8%2BXEkX%2FpEyPPD%2BoiICInFh0ET%2Bl0IHwQOwsJoS6et%2B0UcvAyyxtOK1PUzaWcbiU3deuDrVorXVTN9UXVWm2oFpb%2BeSILNbJrSIAEnl4Ce7g25YJZ3JoSLSJxBX%2BOc5MsQbb53%2F%2FT3C%2FX8sp5t65qRx3A0ukNit5TMS411rKTde2MrGsH0ZN17jDIbCuFay15frNUcQsIUmkhHcGBa9PZzNRa6xnl3FhWTt5SreY3lXMtuDrjRdBTMSbYCBI4PAL7mM%2FrVGNZhvB9DeejJLxPm%2F%2Fl%2F5779TtZ1Xr77eOLF6DoHd64OPxPlrqZ%2FuKt%2FpIdEDqIn0YBaBE8C3sXeyzsmm9a1eV17WZzlnM3V3FTuNKCZecubirnvYJyYd0FV2a8kQAJkMA%2BCDwkR09cmlLA3sM5CLl6kqqgvgkrbyOVVl%2F4W5%2FNLb2LKRSccyRm4FhuFL1jwf74X%2Bq4Ktt0TKrlqpTrqmTL0alG06Qw4pJIRUi6rpdqNiKprYblLKcqXr6u3FRFuemk8tJrWK8KcVSlCeVeu7a91t3jHxQ%2FgQRIIBQE9hA9iQkIgliMeQOC9x1cjK%2F%2FZ%2F8o96trWG8TVp4I3rFdZFP0TtgQxVrmTqWuktWaSmHtqWS5ZpJVPC7XsW%2BYVLXiJQuOnaxmsTCxq7xMS3kuluoooQbL7ZLyRtPK2xxRHsSuM%2BFMd%2BYJGwM8XBI4bgIPEL1OrU0RNdxHIXvtfQX7txBbsPbX%2Fl7%2B5TtV5Rx33ABF77hHzwG%2Bv9YwpVxZJfMltZGrqGSuZDawpfIVs1EomWSuoDeKbiuZQiXzPsRqpuPKJFaVWca%2BD2vRQ%2Bg6FRK69wc4Ar6UBEiABDDx%2F%2BqELBfURtHei0szSEiXNAURwDwqPr3iuuY9lPRa%2F09%2BovCH31z1A%2BWOzcqTA6bonZARvFVUqVTO20jn1UYqa5JbBbWRxD5d8DY2IHbZvLNxJ6OSqJMproV7RqPfyG6LjtbdCel3HiYJ9BqBB6YrBKIn8QGBe1Or5XrT%2BwOnpZYs21r76N%2FNfem4rTyKXq%2BNpvscT71p6sifg8B5G4i23NjImo1kxqRkv57D44y7sQ4BRLkwrmB%2BAvqTh0gCJ53AA0QvSEoPrLggkEWr67mS9znUuNz4m%2F88%2F%2Fl2Mnr3aurHggKWXl8PXPWz6tn9ej9bVNlkzksmsxC9nEmuY4%2Fi0CmIHh4jGmrLSa5C8ApcwfxYfjz8UhIII4E9RE%2FclyJ6LQjLN1M59z%2FCoZj8G%2F914fNIieosN3Ss2HpE9I6VQc99OaIx3WROJVNZldzIiuhB5ODKXM%2FpVCrjbWxm3SRWQEjeXlEbOHgp5cMbCZAACRwJgYfk6Il1J65NEb4qosj%2FZCNnvuZ6XvLif1t6pW0JHruRRdE7kmGy%2Fy8p11RZrDpYdyJ2wQZ3ZjJvkhsQwi0I3hpcmWv4e9uVsP8P5ytJgARI4DEJPDBys5OmELg48%2Fmy%2Bb1U3rvmeTr13I8Xvoznjl3wpOkUvcccAE%2Fy7QhSSfsiB5fmZl6lcJWUxHwerDsJWNGYx3OS6U2IYdmvusIbCZAACRwpAfPlSRQX646T%2B1DkJhaqxloKrlqHa%2FN3Noveu7%2FyRfXVz75clhKJFL0j7a3j%2BbIgNUD%2B19vpAnIkOykDuIck83oqpzY3shC4vNmEyIllt4loTVh5Go%2Fd1FpBbearKpXN%2BiuY80YCJEACR05gR%2FTum64gq6VLwXvPcc27i0nvc5mSWvyh%2F7GIeb2jXTPvYWBo6R3OsOlEMgUJ4JKzIlkrQQ4LNllyw%2FiJnMixy2%2FmTBpzeOnNPPYZs5mExbeZNelUTqfX8s5msqg219Z86%2B7YSvccDiZ%2BKgmQwEki8EDRkyAVg00jzgCRm5WG962bK%2BYL%2BbK38Zd%2FsvxnvWLlCWuK3pMdcSJ20vmdfBVEK2lsRqKWdjb8HarX2sypLczfbUHggn3ebKULWPpnS22lCnornXO21ku4n%2FIXhD3S1YWfLBZ%2BGgmQwNNAYM%2FITaNWcRKsYz7vtbfvul8sV1Xmb%2FyvJVlaqGduFL0n1xWdos2YxNVYVsMXOiyk6E%2Fq7tpQNqwKN2Ymldvespt5nUFkZmaziH3OycLVmUmXVCaXU4Und4j8JBIgARJ4dAIPET0534knatH1TCWVUa98b7H1jcWks%2FS3%2F6%2FGzUf%2Fxif%2FTore4zOVObsWxA1huhp7g2qXvtgF%2BSr%2BhueV5%2B8zRVOAZZdN5nVus2CymzkvB%2FdmdhO5dpi%2Fy25B8LZKKndrVWXxXllkkTcSIAESOHYCHw5ikUPy5%2FaCaRujcjjvrWI%2BL%2F9B0vv89bvem%2F%2FV%2F1b%2BWvvvx378nQOg6D1eV4gFh7wUETUj%2BSmdHJX2Xp4TIUSsSkvVMW%2BXgwszn86bXDLv5TFnl9sqeLnkls5v5p0c8vJyyarKJ5MYPMdcn%2B7xsPDdJEACTxuBB4reznQOVkdXqVpTLb275PzxuyvOjR%2F9Z7Vv9xoHit6j9UiwZpSGqBkRPIhdYO3tFru2CBarpgyxy0HkfMGDdZffKuocSovltwp4LgPBgxtTKqssF1S%2Bc%2Fn0aIfGd5EACZDAkyewZ%2BSmUrfwrRmUHrv%2B5m3vSx%2BseXf%2F1r%2BqvPXkj%2BTxPpGid2B%2Bpm3dicjpHbHzfBGU8jvb1h3SWZoQuQLcmOLCzCPXLr8FS2%2Bz4BUyOZXfLMtjJ49ozTwSzwt57A98OHwDCZAACRwBgYdGbgaBerKOSxF1gb%2Fz9eut15ZSrY1%2F8O%2Ba7x7BoR3oKyB68Z5IGDzQUR%2FPiwPrLpijCyw6sewMhC54vm3lBZZfo2Xq6TxErQiRg%2FCl4c7cymvZF7BiAp7TuUzBKaxlVL7QVPmtLVU6nmbxW0mABEhgbwL3Fb0d12YdUzzfwuLWlcWk%2B9U%2Ff8v52k%2F8fA3lNn0x7KkbRW9%2F3bFj3ckcne%2FK9Ofw7glWCYSvUjdVWHhwXcr8nS6iKkE%2BAwHchOBlYM35Fh8EL1WASxOChxUSyvs7DL6KBEiABI6HwAMiN%2BXcKKlZiDI3rzdbqnR90Xn1le82Xv9ffqX5%2FeM50od%2FK0Xv4Xw6kZlNuDIDsVNty247YrPL8sPf8mVVgnVXQL5dPp3TxQwED%2FN3EDqvgMeFLbgxt6pOfiOp8q0tVVhnwehe%2FF3wmEiABLoIPCSIBedG35pL4dx4rVw3m9%2B56X75S99rvfPPfrUhc3w9d6PoPbhLpCO7Ug52iZ10dFsE%2FchNP2UB83Xiuiz483Z5U8RCr%2BLeLGRg0SH%2FLp8vOQUUkvbn8%2B5u%2BvN3rLDScz8JHhAJkMC9BB6SrgC3pp%2BitYT999I57%2B7Xrjt%2F%2FpU33ff%2F1efqi71IkqJ3%2F17pclu2c%2FB8K%2B%2FeTQJXdMvxVAOuTF%2FwfAsPgpdpW3cQPHFxwpXp5JFsns9uqMIa9oFLgDcSIAES6H0CD7H0qm0D4AamfK4vbarrX%2Fpu4xv%2F9udq1zChJ%2BfMnrtR9HZ3SVei%2BX1ErjsJ3SDZHC7PelNVEZkJwcOGuTrM24k70w9YScOiy1U0ktGdfCYDV2ZNFVhhped%2BAzwgEiCBPQh8OIgFbzCoH2ypCqZ9pALVNdfVN99bdd74wuved%2F7hL1Xe6VWoFL2dngncmb7bcsdl6T%2FXsfJ80duprpIrqWKmZAooJwbR0whSQcBKScOF6RWyeJxCOkKuogqcv%2BvV4c%2FjIgES2A%2BB%2B4qe8tO3RPQkTeurDcfcef1m61u%2F%2F1XnzZ%2F%2F3fqd%2FXzucbyGohdQl85rR2WiA7fn6%2FZwZ4rrUoJWutyZW3lVyJZh6WUcWH3IWYHooWC01M%2Fk%2FN1xjHB%2BJwmQwGMR8AVPbv46el1LConYaT%2FyHJt5FQtgr%2F%2Fp262v%2FP6X1Dv%2F4bWKLHLdk7ewi1537t1OZOa9c3di%2BemgdmalriqScB4EqEDcEJUpVt5WzitmEbDi3y8jOhNRmlVsqLAigscVEnpy%2BPOgSIAE9iLwQNHDagqB4MmyZ%2BaVVF6tvvp645u%2F%2FMXajdfe6t1CG2EWvS7rTiIzO%2Fl391p3O65O5NgVt%2BDO9INWIHgZqawCd2YnHSFXdCRi08%2B%2FyzcggEw43%2Bv3xL%2BTAAn0OIEHBLGIyVeB2GGzVnD%2Fj9%2Ff8BZf%2Bbrznb%2F7b8s32t6znmxZGEVvx7rzc%2B%2F80mE7qyLcJ1ilgWLRgdBhDk8CVmDpZeDC3Mp7mNOTiE2Zz3P8%2B1tISVhM%2B9YdV0joySHPgyIBEjgIgfuKngSxaFUMhE%2B97xn1J2%2Fddm7%2B%2Fjdab%2F2TX6vfPcjnH%2FVrwyZ6H7buOvN3HeG7J1ilWFEVEbwsLDypriJWnczZ%2Be7MMkQOll4u6xRTiMzMlFVxfd0XvJ4M1T3qwcXv61kC1ksvKXu6oKzBKcTfxZWN%2BRjLio7YsaZnNYwX7bO8SCtuolgbLRq%2FpxmOMVGjTcQy0aiH%2B3u1UlvKRlh0BGEPEYS125ZRlrGVxl5jmsjf9vqMXX%2B3%2FYWaETGoXbzR8SzlWVobWcUSTxiNrfv1WLHZ0xHtIOAaf9ZOxFYeVj0xlrzW0lJIy7XwbrzZtftkb7lOTHvNhvaGm0U3XVfuYkU5i4t%2BmpGcQ0JVuvEBlp4YCjmQqGF7q%2BGaP%2FvG9dY7v%2FnH6vu%2F%2FOUKEtV79xYO0Qvqw7Utuge4MretPUk01y1cx0ix6GIW1husO4gdhK%2BoiojKhAsTbk1YfZsVV4pEF9MQu3bBaBG8UP0gendo88geQiDymU%2Bp6IWFsdhLl1qxxFQ8NqhdCFwk5npuzNNWImL0AK7eB5XtDUBOYt2fBcGLQiSCvys1gCF%2Fry7u%2BmoNPYXoJYxWCShcH4Qnjt%2BjjSkFG4JnQ3usg%2FRW%2BwdWw%2BfUPG3qkC3cVy6ex5pu2sX8%2B4dzYI2uQ3xxgjZ1Y3QNIon0Wg9vx%2BstBW03DRxnDU%2FVLdvUXNdqWhqb5TZty27eTrr177zXqi8ulWpffNufywpFnu395%2FOkt%2FwyjFlf9LT6Oi6avv7Kd%2Btv%2FIs%2Fqn0fCXrVg%2FTnUb82DKLXtu6Cqin4UQSuzF1lxHAN2uXWrNRUTSw7EbsMhC5TwL7tzhTh28L9LObvYOkVc5i%2Fy9YhfKyfedRjN8zfJyJhPY%2BtsKDs8ZayGqPYGsoecJTVQvaUm1BWzFG2i1O6i8fRGOTL68N9Y02PmcgnL0Xjn3yuL%2F5Dz1uxKwuxOH4XECIvht8BBEz3wf4aUp4ZxgXgEL5LxO3eG57H3wxeY%2FDavWTL4DOV6t%2FejIrhsyF8In6wAPFhB%2BtQP1xeTq7YNDZTx7GLELWtMbNblEQpLS3h9fIesU4kqRrnAoieB5GUfXACl%2BfldTI9gc9EcXltJPK6cWPFqX3rvVb1zfca1ddvO6ivq1u2pT3LqnutpnJtWJw2rMgmLEPZR%2FG4FlNutKi8OB4XE8odWFTe9c6iqycgwO3BoifCbzJt9l%2FESjLf%2Fv3XnGs%2F%2B0r5g9u3eztSHaIXu8cyOeDYO9hIPbpX%2B9Zd93ydv%2FrB7vk7KR%2B2beH5i722ckVTEqHLiuAV4M4sihsT7kzsfasOll665BRzuF9COsIHKd%2BvLVd%2BvJHAURGI%2FuAllbhyYbDvzOlIYizhJqAfCaXdhOVZIlgJuO36YPvgOQ0Ly%2FTBwZfAScp%2FDI9e38K0bc%2BN2xHZL0zhFA33o1hevgAZcT761h3EUKw4COK9omRUFL%2BX9mvwOt9ye%2BgNhhneo7B5IngidLC9DKw8C4%2Fg8nzou%2B%2FvP%2BkqFeivaQnxkkhpia3XMnd%2F77tgcPqenE6xeBHO4HX%2BHJX%2FnnsuiMWdKYIIEbWUgzJbrbUtt7WWDvaVhgiiqdmwHuG0rRlPixjAAsXeeDVtw3rE3nKtuo64tULNrt1cadVXU9XaalnVel0gHmLpycXDFkjntdafv7PWev3Xvui89Ye%2FUUv1aiWWzvi6j%2Bgd1e%2F2EL5nZ4jvWHO%2BDz4QNF%2Fg%2FPm2jtXXfgx3puOglJhv2YnYQfTKcG364ucVN0s6uI%2BAFax%2FVyyUVCmTVUWUExN3pnwmbyRwZAQuXVLxFy4Mjnz6GWvkR16IDT93IT4CE27Es60RjT3O4Nj0CCRlGEozYjx5rEZwOTuCEzueMyM4UdkWZAbPaX%2B%2Fc60b3JP%2F4Qf078ss2f1uMhe38%2Bq92%2B9%2F5i6Lbn9X2HtPGOy8ojOf97Akoc5r5F33zP%2FtNMJPSgtumC%2FsTjrCHwysZxiIgkhuvvVYQNOK%2BLgCsBUwYVmA67SAC46iPIa6Fzx%2F7xWqTavwje%2FXCl99q1589VqtcO2Ofx7pydsDRE8QSADLJrYkxsfvvPlB89rP%2Fnr5nd%2F8mm8E9LTr92SL3od%2FDDLUA2ETkQvSEHYeG7hEdhLP2xGbyL2rmqpYdyJ6UmUFgSv%2B3F2u6hVRSgzPYbWEglPKwZ0p6QiZqiqhnJh07t4%2Fx54cyjyoYyZgfQaDM%2F1ppackkCStYgl7KB6x3HhL%2B56wuKOjcZwg45ikwl5hb8Vx7vXv9yesvqtn7MSV%2BUj%2F1TOR%2FgvzkQROyv0Yjf0Y32LRBXt5rNp73b6%2F7WLU4lLc%2B9ZLI7yXjqVDbidXWxK1xc0KtyjcrXLf4L7svbbbNHDH%2Bs%2FBoVq9teZUbi27FVh%2BlVurTqXRVA0IZ8OyvQZOZA0YwNhbjYhpNWBmNloVq5HOVBvJjGpcT%2FsuxEMPmHtAjp64giVdAQEr%2Bg7ClH7z1W833%2Fn7v1W99fbbfjRnT99Onug9eOB3BK0tcm3BC1ycMjjaVl47PQEJ5%2FioFtyYcGcGYoeSYpJnV8qWEaFZ0KUtiFxeAlfKcGfi%2BXRGFetbEL4gTJc3EngkAhA8W31G2Z%2FCfNzHL8G3GDFDlquGPQcWmFLDsA78PT58GGPU32NCasTfGzUCZ%2BTg8ICOjAxa9nA%2F9gNW2z0p0ZFwUXpwVfrzZeKy9ANGsN91vzOXtr%2Fj72Wx2V8LDvdVO8IHrZKYAX8%2BUTxM2Lbv4zmZh%2Bx6DkE0pZrXKFa9ZqFsGgXs4XGSZG9cUMv6dKoIGxsWpCrC1CzigqdYbqrC9241i28tucW7d2qFb9%2F2L74P5bZb8OQrthsqRkUZlu4mImDfLtXNr%2F%2Fuq%2FW3f%2FZL9fXr1%2F01RXv6djJE7%2BE%2FOlwMt4WsE6ji%2B%2BXbVl23W3Nn%2Fs6pN00NeXWw3mDVwZ0JK6%2BEtfB8dyaqqpQggkhHcEvi1oRlh7k8VUom%2FQHGcmI9PaSP%2FeDEZWdLkEnlnLKGa8quDik70VR2raki8T5l%2FxACSD5%2BPhr%2F%2BEcisY9d6Iv3D0gwiB7FSWU02GMzcl%2BN4uQiYhfct2SP5%2BGyPNJW9qLodQD0yrE93nF0AnCCfeAulZVYgk0b7DW2YO95pvDGbSd37WYz98bNVu6tO16uVGg0XFs50YhyGwikScSU06wqp9KnnJkZ5SCisuNy3JHoPQbRQ0QP50BdcFyTidjm6wj6e%2FkXfs9966d%2FrZzDRx669fm4Y7%2B3RW%2FvgbTbuvOFzg9YCaIxg3WeOksCBX%2FzlJOvmnJerDoIWa5kfGHz3ZklJJtjEdhsCaKH6Mx0RVybqlTB%2FB3KiZWCqzfeSODBBCB2scFLqm8OQSZXRty%2B8clIwmtZg9p2B%2BCqGoxqb3B%2Byh5GAMnQ6enI8MKkNRSJwAUp7khP9hJwoiTSEe5JBJ7I3n%2BM5wOXJfYITDlobtvT2ml7nyOOruWPdyzybpmekbQLyV6U6RlxhSKNAoFyWtym7YjS9vNbebe8sumVV9JuaQ1bvgIr0TMVbXllbayya5uycewS3KXFSMsrVmMjxczKuvuNTeVduKa8lztBPA8g9KAgFhwognRMFlaoLBz7p4vr3st%2F798Xb37uNf8c2dPzedLU3hO9%2FQ2cHeuuE6gSVPzujs7ccWf6z2vH8bxmviyrmUPo2u5MBK2UchWpm6nluZLvziw5pWJg4ZUkHYHlxI7uvHHSv%2BnFGTXwiZcGhj75jDX8qWfjQ%2FOT9qjreZM4eU1ijmYCv7jJSMSaikXUZBxbLKYnYRpKVCNiHSSCEeEnQd6abBIoEjyv25GOwfN7JQicdIwHO%2F79nTMO9pmP%2BurHP5adT5CFzvxoVIkqRXSpL4id54LnXde0mo6pNVum3nRUreX4Uy8ZjLMt%2FH0Lr8pgAKUQkpTCqEq5LZNaXlal15N9zjdXV92XX95O8%2FhQix8YuQlLFHmNW8i%2BlDm9z%2F3Jd9z%2F73%2F%2BreIG5vNEmHu%2BznDviN7%2BB0u3dSc%2Bc7ki2j1fB2uubeG1X6udSt3UJBBFBE%2Fm72QuT%2Fa5sgerTpd8C6%2FiSl5eKZtTpQJei9XN5cqlpxMtH%2FW3yfc9EoHI3JyKTcdUrH9YxWKJRCze8uCwNHHjmj5jmb6rZ%2BODHzkXGXrmjD30kYvRwYkhmYvzXZKB%2B1JclR13pW7fD3LVgtv%2BfweP1ICn9k29xO3oj6WrcL4%2FpyYX%2FzInuO0Sxf0sBlcG11P%2BvtEyue%2FfadXfWzW163ca9XeQg%2BjUdd2KWnXVrDWK%2Far%2BtZ%2BZDOYLd62uICPUVFquSiMPcRmXX7%2F92c%2FV%2F%2Bjf%2FWltE%2FN54lU7%2BtYfcFAfn%2BgdHM2DrLsPW3ji0hTh8yeVvVauDFGTOTtYcvA%2FI1BFkso13AFeCfN5CFhBSkIQnVnqSkeQCWXO3x1wQD3NL0ek5eDHFvqHL512hy4uxIenhpEOYKlxXIOP4yJrHE6p8elxq39yxOqfGbP6p7H1xfxEb7gjt92W4roMNt3e3y9H7eC%2Fj6cZ%2Fd5t6zVex3M8nblBEUG5LwIoOcSSuB8k2%2FvRpVY7ylRVJYYBuciFdBbrgmLh62LdzcOuzP7YX499YedCTBrTbhAiamBsQvRMKhbRNzCuf%2B1%2F%2BqXmn332ZX8%2B70RM%2F2jz6r3J6XuPr2N4hcDsclduW3f3RGT6c3mdVASn0fIacGfKvJ1vweUqiNSEyOVh3SHhPAhcKehytoLcu6IqJ5FwLi5NJKGfCN%2F0MfRDmL9S%2F8UX1dQPPj849Refi0x96pnoFERtDvlY88i%2FOg0X0jzONHOoqRVHYrgkc%2Feh1BWSu2HFdefAdeeqfThvbTff4zlxntw%2B7jVex388u12lvtWGTXITO3vfkDMVGHNpjN80nk%2FjT5tR2%2F2JHSuv80b%2FxSjqoyqWpd%2FHxdzNt286P%2FNPfqWUfPmaH3Xa8%2FN50pJeF717rLtOuoEvgDuCt7NKwnYgS6lqKnBflhGd6QeqQPjKflpCxSsXUGnF%2F1tFks4duDVVWdIR4Awvc%2F7u5J7zHuPI9blzKo4k7fjsoIpPjSbiluclYlEv4XkR5L%2BZRF%2BfNXD1tB69vBAdu3LGGru8YI8OJOwJ%2FG0C39vZxHUpaQKYo9PYpBjzAxK793Owx3%2FS3M9R9sZrepFVLx3TXscSVLAKUiUM9tp94T6iJ65NTFGrKlIV3sPf3%2FjDb9X%2B5U9%2Frp5CdKhYlD0%2Fn9frohcIWxB96cCo3onM3GX1dVuAqJCO0neIxAzETgJT2vuOO3MLYleUiiplF%2FN5EDm4NNN4jNXNxbrjckC9cQo76qOIvXRFDV9aiI88f94evjQXG0aQyTiqESPww2jQWAAAIABJREFURE3A3TMRj1uj40N6cHzIGhwfsQYmcB%2B1FoPkbz8h3N%2FH8bMXyy4INgmCUPZXdeR%2BLd7rRHXUlB70fb14nL14TN38evb42rVGjSs1V%2B%2Bdz5NnRNwwX2jex1j%2F6j%2F9ncZnf%2FPr1cxJmc%2FrVdELrLtuwZPITH%2Ftu7b7ctfftpPNJfeuLvNyEqSC8F2ZxxPrzndnFuDOhODBxQm3Zt4pIypTAllKxS1VRjkxmbDt%2BfySXjnHneDjuJ8AiZU3%2FCNX45M%2F8mxs6i88F5%2F6%2BGV7GsWJF3DlO4%2BLLez1PH7kY7gKFrdl93b4KI7y5Nhxe%2B2nVd2lvPbz%2BoO85lEvFB71fQc5tif12qPs10c65ransjuIJVitBoaBgTWobmXK3jd%2F6le9%2F%2FNf%2F35J8glPhGuzF0Wv47bcnpfzLbz7ilxHAINVE%2FIVUxGrzg9WKbfFTiw6uDNRRkyiMSF%2BsACRjlCQ6ipwabbLiYmFdyLM8kcau%2BF%2Bk0beXFRNqdjwtIqNTQ3EhpXbh7rCA462B7CwWz9CvgcuzEVGLi3YY1fn7ZGLc%2FbY3JQ9BhcPglP0OPBhw33JkwtSC6S6ibgt91fG60nwf%2FInSKkOIvlgSB30k6F3Cjfv5Lq2X4PfhuWvQNCpKIJqHFLlyM%2BHffCRPf4xywUKUjb8%2Bp%2FtgtTtgtjdxbGlT%2Fzi16g4Y%2BBSDopa477s%2FX7aqxD2k%2BihR%2FuMx2f0aN%2B757u6BU9evH2gUtBbyqthdQXzfjJjvvjjP1f4pVe%2B7c%2FnnZhzaK%2FM6e1Yd9sC1ynZ0%2B3ivNcCRO6dg9w7WG%2BIyiwjMEUqrMgqCeWCJJhXvXJeUhDwOFdzS0WJ1IR7U4SxloZLk%2BXE9hz%2BJ%2FwF0Y99TA08P5oYPH8hMnBp3hrsh9sSJ8gp%2FI6nkPo2iUCUyckha2BsWA%2BI%2B3Ji2B5MxP06lp1E8WB1guDkKaW9Om7Lo8%2BVe3InybbnpONB8ddGk5qRQTK0XzNSN3amFPzfohRqlyV5sJoAXucvHuq%2F7%2BG3Rz0VCt1OfqJwR7Y1TqvtlR1kGaT26g%2FST37%2FtN3MEiXr1xyVFSXabudABHvz1pPH1e607ZrbnYP0DZCg5qbRN%2F6Pzzf%2Bh899rpr75qof5f6oPX3k%2FdILordj3fmCJ27MtnX3ITfndgCL%2F7pKzdSkCoEsB9RxZ0L4IH6BO1PEDlGa5WIlSEeAAJa3WqqE1c3lyoTLAR35cDvaL3weKQZ%2F4eOJsR941hr75PPRsU9ciY2jaPMZRFuegflwBiFsZ6FgUzgqFHOWZXTa%2Bw%2FPxT36vNyTbvKTOUnKb64BUfDXicPpSooli8dD3PwSzCD3y76oifj54oYldIJ15koQvWLX%2Fskc0f04iR2qvGCpIxsVR12pKepfjATFtY03gMfYW1j3D2v6KSWb1CrFOn%2FYy1qAst6f5T8OLlIO72gfvad77pjuI3pBoIv8oQSGq%2FCm3fqF33P%2B9h%2Bh9BiWEpLx1HOteFCHHJ%2FoBYt1dAleu1ZmkGh%2B79YpGC3J6P7fJPdOIjJF5MS688VO3JklRGdC6MSdmYUFWCo65XRNlZFFUsb6dyWWE3v032YPvVNEyHrpJWVNF1DbCysVVG3VZxusP2Cwtpys0o0HF0%2FHxq6etseuzNtjsPLG5qdtcVeKlTeNcQSxg%2BAZrPztr%2B0mbjLfHSbusd6%2BdU4vUq1D1nmT9d6COZUgN0v7a8uJFdbZOqX4RLxazZZuoiiDbI18EYWOK6ZRR0UPRORVg1XFDSpu6BrKWSHfFSuM4wITXsYWlpxr2UDtYn04GL5VbXs12%2FPdnId2Q9K%2F7UXFCWsQN2RQl9tEUEsbAUMeLlQs3%2BKDD7QPFUL6sVySlGjzLT2E4QeWutF43l9fMDE2pKNjA1Z0dFDHxgataCLejrCVftd%2BvweWpCxw668l6K%2F7t2vV%2BMNr6KF98gE%2FWAZXe4DttvQCd3cQxHIX3rR3%2FsEv5P%2F%2Bfzghpce6IRyX6LVFrW3RbZcS286zC%2FLtusXPr0WnHFl%2Bw5%2Bbg9AVYOWJW1OiMAslVFapat%2BdWaiK9eeWt%2FD3CvLu5HWZGlybCFo5SVckBxytYXp55NPnVGQK2%2FPnRiNnTjlRnPgm8KucsJEo7iHiMhFV4xMj9tjkmB6bGrHGkFM3Go%2F6VsAAtkGczAYwxrAiOObm%2FFw6uM9kfxJKfO1cU0spKlnEFGKGqDuxyCzfGpNxXm5bb7DYrEp7LkaqC1UcLGvzwZrbvJtyGosbXuMOtkzBa0LgMF%2FnYh12CJynWrCCHZz3PBCCzmkEs0JULadlXLzOxmta2CLWoYpezEX9QEib1YLgYUYpKuu7K2PjwCIRbAjXRs1jVC%2F1IFyWiroiYBY2uEK1ZfsXMihlGcOboqNDVvz8bKT%2F3KwekP35U9bAQB%2BsRlluKbj4EbeoPA5Wizey1xgr%2FnOHf%2BsZW0kyE7ZdmkG7gzlducCSAtg3sVL66%2F%2FdT%2Bd%2F6osnpPTY8Ymeb911C11H2NrWXSc9oVvsOq5OPFeq6woKRcNlCZGTYBXskVyH%2BTzM3QWCV8b8Xlmqq5QayL3D%2FF1N5u9SqrzOcmKH%2F6M9mm%2FQELz4Cz%2BsYp%2B6PBR75nQ8dvaUJ6sQIMJSLeAEv4A8ogWcCScjth6zI2pU9hFLjcGFKRZdp75lt8C1F0t9jPSCo2l75wTU%2BTa58g7WaJP5OGXkvrgmEWigs7BygtJTcqKyvTzkC1fpVh7CVXj3tld%2F45bTfHOx1fjWu7XGu8uqCT6yXKxBvqK%2Fly%2BR%2B7KHc3H7cWTVjyQxtwOT4KhP1X5fXZLgFtz8skuIr0WfaxFF2eN8vb2X%2B93bR88kBl64aI1%2B4qI18okrkZGPXo6O2rYZwZkJK1r4q1d0ysZJDqYEMEm9VPEQ4ALpCG5HTfNDTbqvlSdPBqvHSzkzbb7%2FE%2F8y%2F9%2F8%2BQeqgpXfxZtw7Ed9kJ45Sktv2zUZjNV2mbDO%2FW7Lzhe%2FHXHElWlLXJaoqOK7MyF4MkcnLkyInFf28%2FLgwvRfU3L8PLwsHrfTEVhO7CAjordeK%2FMwESyNEj2VUFE7piKXZxOJS2ftwWfOWf72kbORgXhUT%2BMUOIOf3iwkbdbfy1W69k9UnbkesfAefOu1n61cWe9aIaRTTB0eD7gc5feDQ26WKqZarpsKPBqVUt2r1htGRK%2Fgr8OG%2BovY48pcFV3HLoNNCauolzBDVkoVmvV3b0VaH6znW2%2BsqdZJyrN63CF69aoaujrZP%2FTieXvo2fPW4IVpmfvTQ45WQ7bWg8bzhrBEz%2FBAQo8N9lljQ%2F3Y4z6eE%2B9Ax%2BUZuEHlQsqPHu1E9vr7x7sd61i8r%2BiJsQLRE0%2BAycJz9s6P%2FXzub2JVhU4VlmM94oPC1uZL0cM%2B4Hvm7u4jeB3h0%2FK33ZZgvalrWPKnXIAFhzkIiJ6ubLszJUgFrkwkoZdLVbeMEmPlslRXwSauTZQTk045EfXgDtpxYXj9woJKzA2q%2FpnJxMDZGbf%2F1ESkf24yOjE7ZibmJu3xU5PWOFyXUg1lBCeenWLOOHnhuZ0al8H9%2FaUYHPavYb8dZyTQREuknFhvvlvS38taa5aBCxP1E42prqVNeWXLraylvfLapltJ5k0ZKRk17eqasXQV83I119G1KAoJY7UtVOK3Gq4XqTetaDOfzrortyCui8p5LZgP7JXW75fSo77OQuHwvrNjqm9qtL9vftbrm%2BiPxB0UD8f8Hza7DysIxIcTemB%2BSg9hKShZLQObNYTI3q7gGATQKFkLUVyj4gL1A2zabtJHPbT2%2B46tJ7pdm3Is8tgPYhGjWlzp2ULVvPmj%2FyL%2Fo3%2FwdX9MnpiozU6PHLboSQ7dPUEpXYEq29bd%2FVyeWPeuoivFthsToCXRvC1yu92ZhYrjuzrh3qzk4OIseaqSzZ6s3JHH%2FIk8jW%2BPokrKyAtX4mMfOWOPPns2Onr2lDWB4INT%2FXGFzTqFE9BcNOIvugpRQ1HnYN05uS9X253VwTv7%2FUdgHtsJZ1c3ygllZwFRIxXz%2FYVEJTE4uG95%2BVsrbun6Had8Y9mUvr%2FUKF%2B%2FbZVchH1E3YaDABDHaSIxURYUxcKi%2FTHl1vqVO15UbnpAeVPXlQex67goj8NVeZzjVrwINgoT2DUs9DvUXug3hjUzGpixjMaUDXepdW4q3vfRC5HEM%2BfsxLNnrcQLF6IJhJBOgn0QCKURGOXB0yAraPgL%2FvoLAY%2FhvswfP97tyMfhfQQvaEHg2pQcPbjOYel95z%2F9O7kfR6qCRMAf%2BVE%2BHlT02iFZentbd%2F6VQ1sQg%2BTY7cdwZyJYBa5MWHft6MyKBKMUxNKTFIWSriASs1yoYo6vDHcmxC6NObxyQVWkfmY67V%2BBnLjOeNzOPEHv7xYgPxLz0iVll0oq0sIJZ9BV9oXzfSPPnrMmPnZZT7xwPjb5scvWOCpinsJr59Czc%2F5eG%2By1RNdJ%2Fhy2Ti7dY5I43JETiMv2umgSMSCxGb47U1Jx%2FBOM66ky1kjLthyTQbRlVlapxkk4h2WMZK4uh3fkXMvK3V1rld677ZXfWHXK33u7Wvn2bV7sPWbvf%2Bjtzz%2BvYs%2BhwMEnnh2J%2FsBVJ%2FbcXCyuPWvGtfUMovhnEPE6g76bRqDUeNTWE7gQG4%2F6930PhKRZdC68gvQLhJniS4KEe1kxsT0%2Fed%2FjPtyxeM9XPlD0EFjoz%2BdVKg21%2BZd%2BKveSuqZaSFU41CCmJ92Pnc87DNG7v3W3S9j89IRu0du%2BX6lp5N55CFDRlWx7HwSseEg5EJGD2FVg0dVcv6C0zGXkIHabED2bASuHNU6e5Of6IvfpTyt9pYS6Xij41YgMDVl2a9BrekOOZQ%2FGbG%2F47Gxk%2FNyMPX52xho%2FM2uNw70kSeUSWNCploK9XFlLYEp70VX%2FBCKLsD7G7dBPMhL2jUhL%2F4ThrxYiealYGduPupQoS0Rb4uSCMnlbeZPfKniFraKXxyrZhbpjFRGVUYa3qWJ5dtnDPl2xq2trrfr76Wp9445qvJ3yr75PTEmox%2Bipo3yrRnpMJIY55WenVOTM%2BKg9P9eKW441ijiZEQSYjiKJcASCN4KI4ZHpETU8MWoNoz7ryMiAuEDbkaDBHLNsmBvsSpMI7j%2B8cszhj8uuiM0O2u0vDc7PxpSqTbX2%2FN%2FJfWpx0Q9gOXGuTWnZkxS93dbdtsj5ZcLuE8SyXV0lmJSHqxMBKhURuxxETaIz8xC0oghezUPUJlydmL%2BDpYe9WylJlRX8XQJWCg1VQcK5WHcsGH2Up4KDf5f%2BzGeUNXZHWXMvKPvUOWUNRQeG%2Blp6CsWmpmDgTSNHbApuy4mxYWsM%2BVRjyKcaGx3SY1iXDvN0QQ4Whq1U4Oj3S08FV8wid52r5%2F27Mfc6%2FsM50cjvoRNtGaxzhkATWG%2By2jUW%2BcQeEZfIn8vfSbmlD1ad0p2UKb2%2FDi9H3qkiVQAOS920YlZDOVbTqVZay65yWqvKcVMISAk8JifyZLRXdxzz3z%2BUGxpDGkTVHuzD6S1hYy7QiXl9I32RxPk5a%2BAC0iEuz0f6LyA9AvPOsPjEFSq5oXCHqrY7VKrIiDvezyn0q8c8PAjmcMbjDtbtNIVdoifmX7sijyqivvHiJ38y95dOcuDTkxK97nm7LlflrlJi7auFtitT5vOsQPgcRzXhzqz4c3hVD65MP7lcXJiw6PAYwSuIyJR5OxE8cXlWSu2%2FIyG9goLRjNA85jPCfr7%2BM%2BKG%2FIyyP7Wg7I9fmrI%2FNteKIGzgjPLsMxC700iOPoPf3Rnb1qN4jFBypBto3EfaAU4akkvXrsHoC5y4hoLbky40fLgnF7lCDvLodjYInVpDO9bQJmx6LZPzMm%2Fe8apv3vCqby%2B1qu%2B9X61egyXnt%2Fb%2B83Ddz%2B%2BnO%2FiaRyNwr2u%2B454MxiRUDJWAIi%2B9OBR%2F%2Fqwbf%2F5ytO8T5yPxU1IYwXhnMIZP42WyP4OexFxgx%2FpDPqB%2FX8qrPeR2WGPz%2FoInByIFEPwKWHCx5%2FFTu%2Fmpv5b96yfVtSkNelzR67bupChtIGxaglW2S4kFcxXd83ddj%2BsNXc8HQgdxwx7zdDJ%2FV6p4VSSZIzAFEZo1JYJYLpedClZHEOtP3JyVdoSmWHgn0rf8aL%2B5E%2FGu4KoYW%2BGSskZgn5y%2BomLnFvoTLy5EE0gK7n%2FhvJWYGMHKBZaNlQyQY2cwP6cl185M4r1BUnBwQuhEYh5twx%2Ft5CLyG8zXyfuDcY4wb7iCkOwt%2B6ajqtWaKVTqplCqecVqXRVajs7CVbkJY3UT5xh%2Fj1zU%2FI2NZv3G7Ujj1p1SvXRdNU7yieZoO68nvs2GCz96YVhFP3JxOHpx0o1OwXuB6b1ZY3mnUOluFmN9FquPTw70qWGkRowgSGtkMKGGYzGNMCNUhOlUhwmqwgTRx482Lh8O5EOC1%2FVFQW41xq5ulaueM%2FSf5%2BX3KUdxYr0JjyN6HSHbFYQCHpK1%2FwDLb1fAiovamVXfXSlzdSgOXYRFJ48LEEERNXneFzy4Nst1x09VkAjNWgtzePh7Lue7NJmS0BO%2F8e2D0BC7iHpJRbEWT%2FTqmaHI1IgXnZ9GZZRxPXZqLDJ2ekqNnhqzIHiIggvKgckPCXsRPPzgd0diSlTm483TPSqfg51gOicCET5oGOqXaBRoVrrboisVK6aYzJlcKuNkN3JeLplVuVLZSJRm0fOsIqICi1HjQRDtSiprt9LlYiu9pBxEynVK8T1qa%2Fi%2BoydgIwjGfm5Y2VNxRIhOjdlDifqgp21EHLujKKg2amM%2BEA7SsVOTamxm3Bo7NR7BpseGBpAoL%2FVDO7VEZS9u0P3cDjZuH%2FCJ7Q%2FpyhctVLzG6H%2BRnznJgieNfRTR61h3gdjJ1aw%2Ffydzdx7u%2B3UAu56%2F536QVLtr%2Fg5XEL6lF8zX%2BdaezN1VC3BdliRCs%2BaUC5KOACsPKzdV2yucn8gckf2M2ZP8GghedOh5FT9zBe6deTf%2B7Ew0PjmJH3a%2Fnh2Km1kk%2FM4OJ6zZeFyJwEkgivywRzAS5UcupZ%2FkihYbil9picjcZ37dYULb30lEfhcSpCLjX1xCsvaYFHDGXB3m6aQ6ijHZdMFs3V51MjdXvcytVXfrgzWTSW65Rc%2FSjRg2pNA1nLpq9MMqLGWVl%2B5THqpeBJ95gq%2BuD7N7evyzt70e9eeR41BRVmJGxQo11RfxMHsd8fpQ5K1vZsIeefaMnrg0b09enrMmLp22sfqHXAz6c4GT%2Fpygf4G4j1SI%2FY3XPbDtCmJpQvDUSL9e1381d7nHee95eAcVvUDQOuHV2%2Ffb7sxO8Mq2ELbn7by2hYc5vM78Hay4KgJUJC1B3JlVicgsibUngSxlVUWSOcQO83f4WydCs4oIzSKWqmdKwp79elwvsD%2F9vEp88spg%2F%2FNXnf5PPjeQ%2BMh5JOxqcxa1Ec%2F4cxkG97HCATZxXQYrj%2B9sJ3Pts8ClGaw5F7g0g71RWzhpJaFWSc8zSTyfRDJ56rs3WunvLTqbb7xv0t%2B%2BUU%2BjJqxUUeEt5AQujKmRlz6KRYwvWFMfuRCZ%2FuTV6NTUmAVXqJqHqyMos4cpAETwojSaD%2Bve%2BcUn5P7sVk0%2FwliKk7so2L2u%2F3Lu2ZPeTfsVPaHQ7cbsDlbpdmc%2BQBSDOT2Zv4PrEnN1cFtWggAVmbcrI1hFglT8eb0qBE%2BiNMuuL4S4X8Fir5U8rLxksl2V4qRTfzqOX%2BbsbH%2FObgSum7qyLsz1D1%2B6YI1enNdjF%2Bf06AWsbjA2gKtVjTwmgzJhymCT%2B7I4qz9hL1tQ0T7Y9%2B5t5zwQuDG1L3JifYnAyX3xPCDtANVSLEuW5anAfZ8t1UwGLs2tUk1lyhVvaz2jcrfXW4X3l9384loz%2F0FBFRB5LEm%2FvJGAmsJyWC%2FMJUYuzrqj5xfs0SsL0REI3%2BRwv5keSFgzI%2F1qGiXRZvrj%2FgLHqADjX1R2imbLBWRHCLsDbA5Itkv0UMQchoeLVSzqWG9yVf%2BV3IsH%2FLCee%2FneohcsER9cvd7rzlRe263ZcXF2vS6Ya9sWx%2Fbad5VSDcJWguDVdFVSEnzXprgx8bwfnYk5vFIgeGWJ0JS5uwa2Vbg38XkSvcbb8ROwkUweWYir6Nw5bOOD0fkJp39iKDZzaszMYm5iZmZMz0yP2pisl%2FJgqFKhpHKKXypMXJqdsmDBkj6BC%2FN45u32w3K3u0iErrNUTxCo4o%2FLINXA3xsPRXl1JpnzCqmMV9jYMoXVjFPcyJpCOmuV1zNOdb1gVTcKtQrynUTw9l6MdT%2FHydc8FQTO4ffRN68GpscS%2FTNTXv%2FsuN1%2FetwanpnQ47NjanxhCnN%2FE9Y4LC9EhKIgNlYXwbjDBgvQyP12dPPO%2FoC%2Fre0Bb2CQNB1XO0gfKum%2FkpXiECf%2B9nDR63ZjdgTMf67Lndntzul2fbZdnQgMamG9rqrvzoQFJ5aeuDDFioN7s9oJWJEKKzm8hgErPT%2BmNEo3xX%2FgkoqfPTUYf27KjZ%2B%2FGI2PxK05FOY9g1mKM%2F196swA7sds%2FwcouUiSX9fJRUJekp9uIPX7j28V8oNg3i16InTBAqxSHzO4EJNglXU8XsfzwR4pCHc3nMqNVa96e8WtvrfkVj%2FYsKrJbK0Bh1Fro6qcwS3VWgxEk8nkB%2BmPcLw2gtqz0b6qikZQbH1kTEWmx%2Fv6r87bQ88sWEMXT%2Bmhy6cjQ%2FNjlhRtWAASREArpENgr2W1ke1lsjqrifjpFPtDtx3E4qGYedNB5PHogC5C9OR7TvztQaInre621D7szuwI4ofm99pW373zd5JoXkW0pp9r51dYCfLyasoXw2LJrWTxGn%2F%2BDsnm5Tw2uIw4f3fsY2zXvAF%2BiPFPYd7uo%2BcTiY9eiPZ%2F7IKdWJi1J7Co50VcDF2EW%2B8Srj5x35zHkUvJJVmUprtMWGcZn2Nv2L4OIEg9CFIQgpuInBRBaC%2Fpo2r4Yw4phHcRvbKIdef8LWI5d6%2FdjjSv3Wq0vv9uqfnOe6r52gmuYrEvVnzRoROQQLHpH1SJj18YSLxwNZr4yLydeGbBjGpbX0Sx7IsYrBfxA7uEQme4708ZdILB5HcoJdG63Z%2F3Od6dgY4yeBKD0cLJvzmUUHm4Ns8degOP4AvuJ3r3m5Bvz9u13Zk7bsv7zfP5z90zfyerJPgBK4HYSeFoXRX3pbg0Kw3Xj9yUCisQwAorrBxBz%2B%2F9FTZGeHQAibYWrjSHRlV0ajQRvzDlDp%2Bbt0cuLUSHL83pEcw7DEctdQo%2FJamDibqYHibcsQ9y7UTs5AqzbdF1lQh7IhFmezfikV%2FhC52%2FnEpnzk7GtWwIOvGLPhfQZqxPhzw7V29hXCdLVbNRrXkb5Ya1Uaq3kjfet5yVzYjz7p1c605dOSe5isUjc%2BQbD4NA5MUXVfwjp1XsytRA%2FPKEGz81HxkcSVgLiJI%2BPdhnLwz1q9ODcX0avzhJeG%2FP%2FbUXyTWoVyuelqCEH8QQrwoe47bzw5Ql3VyIXjyOMnkofg7REyE98bd7RW%2FHuttlycGdaSB4luzvmdvrjtRsiyEm7iVYRVZEQB6eF%2BTbtfPvSmLJSd4d%2FoZ5PQgh0hHE2msnnDexXy74V9Gcvzu%2B4YVJOZVYGMGG9eumB73E7HgkMT0peXZqYmrSnpwdVROz43pieADuFYWamFpqYiqZXJcNKXpBdYr2FhTW7a6c0uuiF6QfYK4Nq5EbzLnp9srkQbmwNP6GzUh05la5ZraSWTeXzqnseraVXcl6uUK%2BL7%2BczbvpNeW%2BV1BuO%2B0gTMv3HN%2FoDcc3b8%2Brj%2BLC9PQU5tUTbmJqQk%2BfmoxMybz69Lienh3R01hXHqs%2BYE49WH5LatfKgrmSDyupQe05dX9lku3ltyB4IoBNjTQalFhrQvAkl%2FapuHVErxOFtiNq29bcdrJ5x6rbidCUMmJShUWE8H7uzBpKi5UC9yXSESCAvtj583kQxark31UgcAVEZmItvEp7SSARPCacH%2BPwguANPHsGC23OxIfOzNlDlzGHgITZ8YG4NTswgHw75NrhSnIGUWQSqILIMakd6NfDbNfG9H8890aP7bhJe1%2FwhL6MwaBGphSEDu5XIXjBnJ1sFjbPrGM5q9yNdVNdTrqVG2tO9dZGrbJeUbVVrDCOyFbv2jU%2FyvNEV7E4xuHIr34wAd9aQwK8Jfl%2FWSTBXxhX0XOjfaNn5%2BzRiwsaUaCR0Qun7NG%2BCHL8sBIEXj%2FtR1Jr1P80qIgUVHtpR09r7E0Mguf%2FVnGVKms6NrCyfAOpCvLep%2BImotedd9fJLwqCVcS6C6qrPNCN2T45uJW6riOx3HdbSjkxP0qz7c6UtAR5XlyYUk%2BzUHEryDDHKgp%2BeoJUlK8w%2F643xhOCVPquTqixKxdiYx%2B9FB974bwae%2FGcPRaJ6AWctU9bllrALwJ7LZPaEom5u%2BDzfibLT4ToaRSDRvqBrH4ggSpBSoK4Mxfx21jC4yUYg4tILF6%2BseqW39mIOEvXc87ylnLeeUW5r%2B0OTjkRLe6NEcijeEQC3XPv1g9fVf0vPDeY%2BOhZp%2F9jlyOJF8%2Fa%2Ff391gwqBUmQy2k%2F2EXy%2FhQE0OCC1cJ6lBJshg2ih4V0fd9Mw7awagc8HfqvZqUSy1NxE9GTSfnueTypqA2RQ%2B3M7mTbToHoIAlXKq74QthVXQXJ5iJocGdC4MSdiXkOeU7m86pwa%2Fp%2Fz0PwyhLMAgtQBLBdMLoTFPBUQD0hjZCrRIkQs0caWDRzQEVQAyX6zIXYxNUFe%2FLKXGTy8llr4uIpa3Js2K8Kjw2WnX%2BVKDl3%2FlXjwW69eerfHbTVHvP1linVUBcTsZYFFEUo1Juq0GggFUHpDWPB2nP1RtRy16sW5u9yicb111Meyq%2B4r6WxMOtrrJ5ysIHBVx8CgQ9FWT%2BzEI0PDKgJEb8BVEeKR%2FRsog9bDNVepOQZFr5F1MoI1HMY2xCEL4IV5CUdp%2FG0pCsIZ21ejWJZk%2B0KEoHYBaWUPjy%2Fd89zWGG4geRbicKsSoK5iJ0EpoiYiTuzWPdLi23ik8b0AAALnklEQVSXEytWHDynKiiy60dxSg5eHmXF8F3MUzqEUf%2BQj7QkCnPMUn0TMyo%2BPtQXnxk0fdOo%2FYcamdOnxv%2F%2F9s4lNq6zDMPnn5udxo5jexwn40vTgiiW0nTDAokNEgs2lViygg0rJFgisUIVElsQ26pStyxYsGHBZQUSG4QoSqKogqZpXIyc2OPGnpnj25nD%2B%2F1nTuI4adRFHI%2Fne0YajdNK4%2Fmf77dff%2FfqfGu2cmlhLlxSbsBGH1m%2BruyzU74u5gSePw3%2B6DcfTrErPmExQd68uhjK0X%2FQ12FPO%2Bw2Nz%2Frbz7YzjcVet%2FUXrtN5e7a%2Bou4reloeubtatZv915J292NJLvV1ciwQvDKMOYwn%2Frl3ja%2B22kRCAp91rWtpG5hT8v7LU72682mxoBeCNMzk8nM%2FFQyPT1VmZmdUG6%2Bks8eHCZzcvE0UCKfrYYwq4pQ5f7C7qi0KxSi96e6mmkHvXfHi1WeU6UZm83lvdlsTPPoynBmOV0lVmfGXjzL6cXqzDhOTPvvejY%2Fc5C%2Fs5ARPUov%2BUei1Upe%2BZLydgtT4%2BcX5%2FsTi83q%2BYVmZeriherlC5P5lemJcFnNqHqtXK7Z9uckTn0o8nVBX3%2FRwbefd65hkoMQc3bFNJUQ4iJXhXe2P1nP7ttzVWPD7q3n66v3s%2FudNLPVKt08r3TH9Kz00253LunduZPkk5NJPhA8O135fMmW5dtB4CkCFva0opeqbTsZn0yqrSXlABvnz11dPDy%2FPF%2BbaM1UJpYuhYlWszaZH%2FZbVXmAasG5Uq3llrNvqYjlrVHiaqKnmYCDYpXjvXeDAhUFa2KhiomjNSqqNFveXGw2t40Ien0czrTqTAtnWigzVmgqnLkjz04C2LNxYlsSvWQ96a4XfU7D9OtvlOz6uWe5qmkP89eSqevLY1Mrr1cvfGUhXFxZrl8YH%2Bu36o2woO3PC2P1pGU5vHpVQ6GL3h61Hij4aeXNRYXXF2xyfcbHGD6L21Do2HoQWxDUimCjwz78JFu7vZqv3b6brf179WDt1urhfw90d%2Fcb2hiqxvLueHKoIpVMbQhl0dUTAwtdXCYOeZYIHC0ss00oobGY1N78qlZ%2BLU00Lrey8evLjcYbC7XGeD1frH%2B7%2FedR%2Ff2s8GZt9dFmhKc9uyfCnLv7YS%2Fm6RS2jK%2FF7rvo0ZXhTLUepFacUk5XsXYEjRmL4cxdvWrhq%2F1VbdVwPE6WwKOllvo2lS%2Frkj%2BcS%2BpvLZ%2Bbufb64czKa2PTK0vJzMqr1dnmVAxhWp%2Bdxgxpr12ivrv47xe44eD0xa78BEc9MRMs5en0DNqGYJsQkv7meju%2Ff%2FPjbO3GR9n%2F%2FvXx4dqNewdr%2F7gVp6xQVXyyd5Z3f%2FkEgvb%2BVd88l1Rnl5LqO%2B%2FGwQv2OP2f2BNiYZ6egjNHcnoDj06%2FBB4Xsuj%2F669fK06JYcztjoZGa3amFadYONPCnB3bbl702%2FUe7mXRC7R2BPPsbP%2Fdugkf%2BbsTMuNTbxsby8eaSX1mPqlrTU19YuZco3Uxm16%2BVGm%2BeqXWXJpP5q7qdbGp%2BH0uj04xfImeTW8v5%2FfZFoQX9zj9H6FyPU%2FZZG7LMRVt0OLWoGeeP3r9dL3%2F4IM7%2FY0bHx1s3L7b37h5d3%2Fjn%2F%2BxjQmj%2B4vgxRmadzqDBI5Hbk7%2Fp%2FUEIZrofaj3f7JwpazmHPTeaXZmarm7YgOCClbSkJbVmRbO7OyqTcFCmVaRuZv1ynYEC2lqunzPxolpfYqFM8nfnaAxeWsIQAACEHg%2BAavevBk9vWcIn%2FXeyZOL3p0mq8irk7gNwpmd3X6qvF4sUIk5O8vrpYfy%2BIp2hIeHhZdX0TogxYXMZR7pvx64aBCAAAQgMPwEQv7H%2BgexSOVIsUrsvdMoMRO56K3ZDjx9HUOWthlBXl23aE%2Fo9SxnFwtZHrcjtCV6lr%2FTOiDz7sjfDf894BNCAAIQcEHAwpt%2F10mLnjx5fHtZsr%2FTzbXYtfDqzNOL1ZnWXB69Pb3uqS%2FPvDkLXSqcWbYjqIAltXFi8vJS5e%2BsYMXWpvCAAAQgAAEIDAUBE72%2FlaFN9d7txiWulrOTdxd78CRk1nqwI%2FEzwfusI8Gzf%2B%2FpqWWvZTtCmb9T%2F12P%2FN1Q2JYPAQEIQAACxwiY6P3Feu862nUnsYseXadoS5DwFeFMeXypPD8rZLECll5PhSuWvzNPL7WB0gpzblnf3VrSU%2F7OQpo8IAABCEAAAkNHIKS%2Fb%2FwhhjC7IbVKy9h4nkrcinYEq75MbQWQxC7tWjizm8WwZ1dPK1Tp7CUp64CGzq58IAhAAAIQeAaB8Olvar%2BNBSsWziw8vafCmdqCEP%2Bb5e9Undmz7Qg7mTy8tsRRr1tb0bsjf8cVgwAEIACBoSYQbr5Xf1%2F5O01UKTy9MpxpLQjm2SmEqZBm6KUKZ1rzubaap%2Bbp2Uimh1mSKn9nBSu2L4wHBCAAAQhAYKgJhL%2F%2Bsvbr4%2BFMq9aMnp28PpuuYqHMWKkpAdwatCNonJj13pG%2FG2rz8uEgAAEIQOAogfC7n9d%2BUVZnxtDmYLyYqjFTm66inJ3yeNaukOz29ov%2Bu3saL6Y30RoWHhCAAAQgAIGzQyC8%2F5PKT82Di%2BFMTVZRCDN%2BbdWZajzX1JVYnRlDn5a%2Fa7ej4DF49%2BzYmE8KAQhAAAIDAuFXP6z8eMfaE1SgEkVP7Qid3mFq%2BTtrR7BxYvvWqqD%2BOy3JNMEjf8f1gQAEIACBM0kg%2FOx71R9Ye4IET4OjM23FVAN6LGhR%2Fk5CuKdVQLnyd%2FTfnUn78qEhAAEIQOAIgfCj71S%2F21NF5raWvZb5O5u8Qv8d9wQCEIAABEaNQPj%2Bt6pvy8OzXXhpVxNYynFi9N%2BNmqk5DwQgAAEIhLe%2FnnwzVWhzW5WZNmJsf7D%2FjvwdlwMCEIAABEaNQPjGteRr6V7Sjfk77cJbU%2FGKDkn%2F3ahZmvNAAAIQgEASrr%2BWvNFVL94DW%2F7K%2FjuuBAQgAAEIjDCBsNRMWp1Mnh7zM0fYzBwNAhCAAASMQGg2k0n233EZIAABCEDAA4Hg4ZCcEQIQgAAEIBA9PTBAAAIQgAAEvBBA9LxYmnNCAAIQgACeHncAAhCAAAT8EMDT82NrTgoBCEDAPQFEz%2F0VAAAEIAABPwQQPT%2B25qQQgAAE3BNA9NxfAQBAAAIQ8EMA0fNja04KAQhAwD0BRM%2F9FQAABCAAAT8EED0%2FtuakEIAABNwTQPTcXwEAQAACEPBDANHzY2tOCgEIQMA9AUTP%2FRUAAAQgAAE%2FBBA9P7bmpBCAAATcE0D03F8BAEAAAhDwQwDR82NrTgoBCEDAPQFEz%2F0VAAAEIAABPwQQPT%2B25qQQgAAE3BNA9NxfAQBAAAIQ8EMA0fNja04KAQhAwD0BRM%2F9FQAABCAAAT8EED0%2FtuakEIAABNwTQPTcXwEAQAACEPBDANHzY2tOCgEIQMA9AUTP%2FRUAAAQgAAE%2FBBA9P7bmpBCAAATcE0D03F8BAEAAAhDwQwDR82NrTgoBCEDAPQFEz%2F0VAAAEIAABPwQQPT%2B25qQQgAAE3BNA9NxfAQBAAAIQ8EMA0fNja04KAQhAwD0BRM%2F9FQAABCAAAT8EED0%2FtuakEIAABNwTQPTcXwEAQAACEPBDANHzY2tOCgEIQMA9AUTP%2FRUAAAQgAAE%2FBBA9P7bmpBCAAATcE0D03F8BAEAAAhDwQwDR82NrTgoBCEDAPQFEz%2F0VAAAEIAABPwQQPT%2B25qQQgAAE3BNA9NxfAQBAAAIQ8EMA0fNja04KAQhAwD0BRM%2F9FQAABCAAAT8EED0%2FtuakEIAABNwTQPTcXwEAQAACEPBDANHzY2tOCgEIQMA9AUTP%2FRUAAAQgAAE%2FBBA9P7bmpBCAAATcE0D03F8BAEAAAhDwQwDR82NrTgoBCEDAPQFEz%2F0VAAAEIAABPwQQPT%2B25qQQgAAE3BNA9NxfAQBAAAIQ8EMA0fNja04KAQhAwD0BRM%2F9FQAABCAAAT8E%2Fg99EShaIUEKdgAAAABJRU5ErkJggg%3D%3D diff --git a/pbserver.py b/pbserver.py index 4185aa0..d1fcc32 100755 --- a/pbserver.py +++ b/pbserver.py @@ -1,19 +1,19 @@ #!/usr/bin/python2.7 from bottle import route, run, post, request, static_file -from pb.Gradient import Gradient -from pb.Imgrid import Imgrid -from pb.Breaker import Breaker -from pb.Pattern import Pattern -from pb.Generate import Generate -from pb.Imlandscape import Imlandscape +from Pb.Gradient import Gradient +from Pb.Imgrid import Imgrid +from Pb.Breaker import Breaker +from Pb.Pattern import Pattern +from Pb.Generate import Generate +from Pb.Imlandscape import Imlandscape -from pb.Config import AWS_SECRET_ACCESS_KEY, AWS_ACCESS_KEY_ID, BUCKET_NAME, BIN_IDENTIFY -import pb.lib.Utils as utils +from Config import AWS_SECRET_ACCESS_KEY, AWS_ACCESS_KEY_ID, BUCKET_NAME, BIN_IDENTIFY +from Pb import Pb +from Db import Db import os import sys -from pb.lib.Db import Db import sha from subprocess import call, Popen, PIPE @@ -61,13 +61,13 @@ def s3move(filename,objectname): def format_im_data(im, insert_url="NULL"): directory = hashdir(im.filename) dimensions = bin_identify(im.filepath) - size = utils.file_size(im.filepath) + size = Pb.file_size(im.filepath) objectname = "im/{}/{}".format(directory, im.filename) try: s3move(im.filepath, objectname) cleanup(im.filepath) db.insert_cmd( - date=im.now, + date=im._now, remote_addr=request.environ.get('REMOTE_ADDR', "NULL"), username=im.params.get('username', "NULL"), url=insert_url, |