Der Code-Schnippsel-Thread

# imgur album downloader prototype


imgur_album_id = '7a7iA'


# ------------------------------------------------


import urllib.request
import re


imgur_album_url = 'http://imgur.com/a/' + imgur_album_id
matcher = re.compile(r'href="http://i\.imgur\.com/([a-zA-Z0-9]{5,}\.(jpe?g|gif|png))"')


album_stream = urllib.request.urlopen(imgur_album_url)
for line in album_stream:
    # HURRRRRRR
    if 'target="_blank"' in line:
        match = matcher.search(line)
        if match:
            filename = match.group(1)
            imgur_image_url = 'http://i.imgur.com/' + filename
            print 'Downloading ' + filename + ' ...'
            urllib.request.urlretrieve(imgur_image_url, filename)
album_stream.close()

#!/usr/bin/python


import sys
import os
import audiotools
import hashlib
import tempfile
import base64
import shutil
import string


sumsfile = "~/.pushm3ucache/checksums"


deviceFormats = ["mp3", "m4a"]
convertFormat = audiotools.MP3Audio
convertQuality = "extreme"


def pathize(path):
  return os.path.abspath(os.path.expanduser(path))


def parsem3u(filename):
  print "Reading m3u file..."
  files = []
  f = open(filename, 'r')
  for line in f:
    if (line[0] != '#'):
      path = pathize(os.path.join(os.path.dirname(filename), line.strip()))
      if (os.path.exists(path)):
        files.append(path)
      else:
        print("What the hell is '" + line + "' doing in your .m3u file? "
           + "I don't know what that is.")
  return files


def printAudiotoolsInfo():
  print "pushm3u using audiotools " + audiotools.VERSION
  print "supported types: "
  for k, v in audiotools.TYPE_MAP.iteritems():
    print k + " with supported compression modes " + str(v.COMPRESSION_MODES)


def getNewSums(files):
  print "Getting new checksums..."
  checksums = {}
  for file in files:
    md5 = hashlib.md5()
    with open(file, 'r') as f:
      for chunk in iter(lambda: f.read(128*md5.block_size), b''):
        md5.update(chunk)
    checksums[file] = md5.digest()
  return checksums


def getOldSums():
  checksums = {}
  key = ""
  if os.path.exists(sumsfile):
    f = open(sumsfile, 'r')
    for number, line in enumerate(f):
      if (number % 2 == 0):
        key = line.strip()
      else:
        checksums[key] = base64.b64decode(line.strip())
  return checksums


def writeSums(checksums):
  f = open(sumsfile, 'w')
  for k, v in checksums.iteritems():
    f.write(k + '\n' + base64.b64encode(v) + '\n')


def filterChanges(files, oldSums, newSums):
  newFiles = []
  for file in files:
    if file not in oldSums or oldSums[file] != newSums[file]:
      newFiles.append(file)
  return newFiles


def convert(filename, audio):
  print "Converting " + os.path.basename(filename) + "..."
  newFile = tempfile.NamedTemporaryFile().name
  audio.convert(newFile, convertFormat, convertQuality)
  newAudio = audiotools.open(newFile)
  newAudio.set_metadata(audio.get_metadata())
  return newFile
  
def getCopyables(files, audios):
  copyables = []
  for file, audio in zip(files, audios):
    if audio.NAME in deviceFormats:
      copyables.append(file)
    else:
      copyables.append(convert(file, audio))
  return copyables


def destMap(srcs, newSrcs, dest):
  if (len(srcs) > 1):
    prefix = os.path.commonprefix(srcs)
    print "stripping " + prefix + " from the paths."
  dsts = map(lambda x : os.path.join(dest, string.lstrip(newSrcs[x], prefix)), srcs)
  destMap = dict(zip(srcs, dsts))
  return destMap
  
def copyAll(origs, news, dests):
  print "Copying..."
  for orig, new in zip(origs, news):
    dest = dests[orig]
    dir = os.path.dirname(dest)
    if not os.path.exists(dir):
      os.makedirs(dir)
    shutil.copy(new, dest)


def getNewSrcs(files, audios):
  newSrcs = {}
  for filename, audio in zip(files, audios):
    if audio.NAME in deviceFormats:
      newSrcs[filename] = filename
    else:
      base, ext = os.path.splitext(filename)
      newFile = base + '.' + convertFormat.SUFFIX
      newSrcs[filename] = newFile
  return newSrcs
  
def delIfEmpty(dirname):
  if os.listdir(dirname) == []:
    print "removing empty directory " + path
    os.removedir(dirname)


def visitCrap(dests, dirname, names):
  for name in names:
    path = os.path.join(dirname, name)
    if os.path.isfile(path):
      if path not in dests.values():
        print "removing file " + path
        os.remove(path)
    elif os.path.isdir(path):
      delIfEmpty(path)
  delIfEmpty(dirname)


def deleteCrap(dest, dests):
  os.path.walk(dest, visitCrap, dests)


def pushm3u(src, dest):
  printAudiotoolsInfo()
  srcs = parsem3u(src)
  checksums = getNewSums(srcs)
  newSrcs = getNewSrcs(srcs, audiotools.open_files(srcs, False))
  copyFiles = filterChanges(srcs, getOldSums(), checksums)
  copyables = getCopyables(copyFiles, audiotools.open_files(copyFiles, False))
  dests = destMap(srcs, newSrcs, dest)
  copyAll(copyFiles, copyables, dests)
  writeSums(checksums)
  deleteCrap(dest, dests)
  
# MAIN #
if (len(sys.argv) < 3):
  print "usage: pushm3u source.m3u destination"
else:
  src = pathize(sys.argv[1])
  dest = pathize(sys.argv[2])
  sumsfile = pathize(sumsfile)
  pushm3u(src, dest)

@echo off
:a
IF X%1==X GOTO e


ffmpeg.exe -i %1 -vcodec libx264 -acodec libmp3lame -ab 96k %1.mp4


shift
GOTO a
:e

"""
Util to hash a password securely and generate the sufficient random Salt.
"""
__author__ = 'Thomas Lercher'
__version__ = '0.1'


import hashlib
import os
import binascii


def randomSalt():
    return binascii.b2a_uu(os.urandom(45))


def hashPassword(password=None, salt=None, sha1Hashed=True):
    if(password is None):
        raise RuntimeError('The Password cannot be empty')


    if(sha1Hashed):
        hashed_password = xstr(salt) + password
    else:
        hashed_password = xstr(salt) + hashlib.sha1(password).hexdigest()


    return hashlib.sha256(hashed_password).hexdigest()


def xstr(s):
    if s is None:
        return ''
    return str(s)