GPU-Mining-Profit. Zeit, aufzuwachen?

hier mal das script... ist auf dem CryptoSwitcher von area aufgebaut...
dauert recht lange bis er alle daten hat... hatte das abgeändert da coinchoose oft down war und ich die korrekten diff haben wollte...
bin totaler anfänger mit python...

Code:

####################################################
# Altcoin Switcher                                 #
# for most coins listed on Cryptsy                 #
# thx to area for his CryptoSwitcher without his   #
# coding style i would have not started playing    #  
# around with python  :)                           #
#                                                  #
# TipJar (BTC): 1H6L4VjrmRizXLLbrKLJQyx7vg87ZLjubD #
# Author: minime                                   #
####################################################


import urllib2
from bs4 import BeautifulSoup
import urllib2
import shutil
import os
import time
import paramiko
import subprocess
import numpy as np
import sys
# Ugly hack so git submodule init is adequate.
sys.path.insert(0, './PyCryptsy/')
from PyCryptsy import PyCryptsy
import itertools
import ConfigParser
import re
import simplejson
import socket

class Coin:
  def __init__(self, name):
   self.ratio=0 # assume totally unprofitable unless otherwise shown to be the case.
   self.willingToMine = False
   self.miningNow = False
   self.willingToSell = False
   self.command = '' # coins['arg'].div = float(coins['arg'].div.sting)the command that is run when we want to mine this coin.
   self.name = name
   self.cnt = 0
   self.median = 0
   self.m = 0
   self.h = 0
   self.fee = 0
   self.source = '--'
   self.price = 0.0
   self.div = 9999999999.9 # start off with ridiculously high diff so we dont mine the wrong coin
   self.reward = 0
   self.algo = ""
#list of Coins
coins = {}
coins['btc'] =  Coin('BitCoin')
coins['42'] =  Coin('42Coin')
coins['leaf'] =  Coin('LeafCoin')
coins['dgc'] =  Coin('DigitalCoin')
coins['glc'] =  Coin('GlobalCoin')
coins['lot'] =  Coin('LottoCoin')
coins['eac'] =  Coin('EarthCoin')
coins['arg'] =  Coin('Argentum')
coins['bqc'] =  Coin('BBQCoin')
coins['doge'] =  Coin('DogeCoin')
coins['frk'] =  Coin('Franko')
coins['anc'] =  Coin('AnonCoin')
coins['ftc'] =  Coin('FeatherCoin')
coins['cnc'] =  Coin('CHNCoin')
#coins['btb'] =  Coin('BitBar')
coins['mec'] =  Coin('MegaCoin')
coins['ltc'] =  Coin('LiteCoin')
coins['wdc'] =  Coin('WorldCoin')
#coins['nvc'] =  Coin('NovaCoin')
coins['mnc'] =  Coin('MinCoin')
coins['tag'] =  Coin('TagCoin')
coins['phs'] =  Coin('Philostone')
coins['cmc'] =  Coin('CosmosCoin')
coins['sbc'] =  Coin('StableCoin')
coins['fst'] =  Coin('FastCoin')
coins['elc'] =  Coin('ElaCoin')
coins['crc'] =  Coin('CraftCoin')
coins['lky'] =  Coin('LuckyCoin')
coins['gld'] =  Coin('GoldCoin')
coins['csc'] =  Coin('CasinoCoin')
coins['dmd'] =  Coin('Diamond')
coins['cat'] =  Coin('CatCoin')

# Read in config file
Config = ConfigParser.ConfigParser()
Config.read('./Switcher.config')

# Enable the coins you want to mine here.
for key in coins:
    try:
        coins[key].willingToMine = Config.getboolean('MineCoins','mine'+key)
    except:
        continue

# You should have scripts that stop all other forms of mining, set
# your clocks and environment variables appropriately, and start
# mining the appropriate coin. I have these called 'litecoin.sh',
# 'bitcoin.sh' etc., but edit and/or replace these as you see fit.

# Any coins you aren't mining you can just leave blank.
for key in coins:
    try:
        coins[key].command = Config.get('Scripts',key+'script')
    except:
        continue




#defibe idletime 5 min standart
try:
    idletime = int(Config.get('Misc','idletime'))
except:
    idletime = 5
    


# create http handler
opener = urllib2.build_opener()
opener.addheaders = [('User-agent', 'Switcher')]

extout = True

# main loop
cnt_all = 0
while True:
    # print header
    print "time:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

    # get data from sources
    prestr = "getting data... "

    #getting dificulty of BitCoin needed as basis for Calculation
    req = urllib2.Request("http://blockexplorer.com/q/getdifficulty")
    f = opener.open(req, timeout = 15)
    coins['btc'].div = simplejson.load(f)
    coins['btc'].reward = float(25)
    #getting price of Bitcoin @Bitstamp needed as basis for Calculation   
    #req = urllib2.Request("https://www.bitstamp.net/api/ticker/")
    #opener_cyp = urllib2.build_opener()
    #f = opener_cyp.open(req, timeout = 15)
    #data_cyp = simplejson.load(f)
    #if coins['btc'].price < float(data_cyp['last']):
        #coins['btc'].price = float(data_cyp['last'])

    #getting Data from Cryptsy 
    i=0
    while i < 5:
	try:
         req = urllib2.Request("http://pubapi.cryptsy.com/api.php?method=orderdata")
         opener_cyp = urllib2.build_opener()
         f = opener_cyp.open(req, timeout = 20)
         data_cyp = simplejson.load(f)
	 if i == 5: break
	 i+=1
        except:
            continue

    
    # loop through coins
    for abbreviation, c in coins.items():
        # only get profitability for coins which we are interested in.
        # this saves network traffic and running time
     if c.willingToMine==False:
         continue

     success = 0
     #assign Prices from Cryptsy to coins
     fullstr = prestr + "price of " + coins[abbreviation].name + " at Cryptsy"
     print fullstr + (79-len(fullstr))*" " + "\r",
     for item in data_cyp['return']:
       if item.lower()==abbreviation:
         if data_cyp['return'][item]['secondarycode']=='BTC':
           if coins[abbreviation].price < float(data_cyp['return'][item]['buyorders'][0]['price']):
               coins[abbreviation].price = float(data_cyp['return'][item]['buyorders'][0]['price'])   
     
       if abbreviation == '42':
           try:
	       fullstr = prestr + "difficulty of " + coins['42'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
               usock = urllib2.urlopen('http://altexplorer.net/chain/42', timeout = 15)
               data = usock.read()
               usock.close()
               soup = BeautifulSoup(data)
               v = soup.findAll('td', limit=10)
               coins['42'].div = soup.findAll('td')[9]
               coins['42'].div = float(coins['42'].div.string)
               coins['42'].reward = float(0.000042)
           except:
               continue

       if abbreviation == 'leaf':
	   try:
	       fullstr = prestr + "difficulty of " + coins['leaf'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
               req = urllib2.Request('http://explorer.leafco.in/chain/leafcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['leaf'].div = simplejson.load(f)
               coins['leaf'].div = float(coins['leaf'].div)
               coins['leaf'].reward = float(250000.50)
           except:
               continue

       if abbreviation == 'glc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['glc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://blockchainx.com/chain/Globalcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['glc'].div = simplejson.load(f)
	       coins['glc'].div = float(coins['glc'].div)
	       coins['glc'].reward = float(100)
           except:
               continue

       if abbreviation == 'lot':	
	   try:
	       fullstr = prestr + "difficulty of " + coins['lot'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://lottocoin.info/chain/lottocoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['lot'].div = simplejson.load(f)
	       coins['lot'].div = float(coins['lot'].div)
	       coins['lot'].reward = float(32896)
           except:
               continue

       if abbreviation == 'eac':
	   try:
	       fullstr = prestr + "difficulty of " + coins['eac'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://earthchain.info/chain/EarthCoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['eac'].div = simplejson.load(f)
	       coins['eac'].div = float(coins['eac'].div)
	       coins['eac'].reward = float(10000)
           except:
               continue

       if abbreviation == 'arg':
	   try:
	       fullstr = prestr + "difficulty of " + coins['arg'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://arg.webboise.com/chain/Argentum/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['arg'].div = simplejson.load(f)
   	       coins['arg'].div = float(coins['arg'].div)
	       coins['arg'].reward = float(3)
           except:
               continue

       if abbreviation == 'bqc':	
	   try:
	       fullstr = prestr + "difficulty of " + coins['bqc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://bbq.cryptocoinexplorer.com/chain/BBQCoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['bqc'].div = simplejson.load(f)
	       coins['bqc'].div = float(coins['bqc'].div)
	       coins['bqc'].reward = float(42)
           except:
               continue

       if abbreviation == 'doge':	
	   try:
	       fullstr = prestr + "difficulty of " + coins['doge'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://dogechain.info/chain/Dogecoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
	       coins['doge'].div = simplejson.load(f)
	       coins['doge'].div = float(coins['doge'].div)
	       coins['doge'].reward = float(250000)
           except: 
	       continue

       if abbreviation == 'anc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['anc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://explorer.anoncoin.net/chain/Anoncoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['anc'].div = simplejson.load(f)
	       coins['anc'].div = float(coins['anc'].div)	   
 	       coins['anc'].reward = float(5)
           except:
               continue

       if abbreviation == 'btb':
	   try:
	       fullstr = prestr + "difficulty of " + coins['btb'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://btb.cryptocoinexplorer.com/chain/bitbar/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['btb'].div = simplejson.load(f)
	       coins['btb'].div = float(coins['btb'].div)
	       coins['btb'].reward = float(0.20)
           except:
               continue

       if abbreviation == 'mec':
	   try:
	       fullstr = prestr + "difficulty of " + coins['mec'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://mega.rapta.net:2750/chain/Megacoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['mec'].div = simplejson.load(f)
	       coins['mec'].div = float(coins['mec'].div)
	       coins['mec'].reward = float(25)
           except:
               continue


       if abbreviation == 'mnc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['mnc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       usock = urllib2.urlopen('http://mnc.cryptoexplore.com/', timeout = 15)
	       data = usock.read()
	       usock.close()
	       soup = BeautifulSoup(data)
	       j = soup.findAll('td', limit=5)
	       coins['mnc'].div = soup.findAll('td')[4]
	       coins['mnc'].div = float(coins['mnc'].div.string)
	       coins['mnc'].reward = float(2) 
           except:
               continue

       if abbreviation == 'meow':
	   try:
	       fullstr = prestr + "difficulty of " + coins['meow'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://kittehcoinblockexplorer.com/chain/Kittehcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
	       coins['meow'].div = simplejson.load(f)
	       coins['meow'].div = float(coins['meow'].div)
	       coins['meow'].reward = float(25500)
           except:
               continue 

       if abbreviation == 'sbc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['sbc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://sbc.blockexplorer.io/chain/Stablecoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['sbc'].div = simplejson.load(f)
	       coins['sbc'].div = float(coins['sbc'].div)
	       coins['sbc'].reward = float(25)
           except:
               continue  

       if abbreviation == 'frk':
	   try:
	       fullstr = prestr + "difficulty of " + coins['frk'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://frk.cryptocoinexplorer.com/chain/Franko/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['frk'].div = simplejson.load(f)
	       coins['frk'].div = float(coins['frk'].div)
	       coins['frk'].reward = float(0.25)
           except:
               continue     

       if abbreviation == 'ftc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['ftc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://ftc.cryptocoinexplorer.com/chain/Feathercoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['ftc'].div = simplejson.load(f)
	       coins['ftc'].div = float(coins['ftc'].div)
	       coins['ftc'].reward = float(200)
           except:
               continue 

       if abbreviation == 'nvc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['nvc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://nvc.cryptocoinexplorer.com/chain/Novacoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['nvc'].div = simplejson.load(f)
	       coins['nvc'].div = float(coins['nvc'].div)
	       coins['nvc'].reward = float(9.58)
           except:
               continue 

       if abbreviation == 'wdc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['wdc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://wdc.cryptocoinexplorer.com/chain/Worldcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['wdc'].div = simplejson.load(f)
	       coins['wdc'].div = float(coins['wdc'].div)
	       coins['wdc'].reward = float(50.2834)
           except:
               continue 

       if abbreviation == 'dgc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['dgc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://dgc.cryptocoinexplorer.com/chain/digitalcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['dgc'].div = simplejson.load(f)
	       coins['dgc'].div = float(coins['dgc'].div)
	       coins['dgc'].reward = float(15)
           except:
               continue

       if abbreviation == 'fst':
	   try:
	       fullstr = prestr + "difficulty of " + coins['fst'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://fst.webboise.com/chain/Fastcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['fst'].div = simplejson.load(f)
	       coins['fst'].div = float(coins['fst'].div)
	       coins['fst'].reward = float(32)
           except:
               continue

       if abbreviation == 'elc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['elc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://elc.webboise.com/chain/Elacoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 25)
 	       coins['elc'].div = simplejson.load(f)
	       coins['elc'].div = float(coins['elc'].div)
	       coins['elc'].reward = float(2.16594)
           except:
               continue

       

       if abbreviation == 'crc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['crc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://crc.cryptocoinexplorer.com/chain/CraftCoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['crc'].div = simplejson.load(f)
	       coins['crc'].div = float(coins['crc'].div)
	       coins['crc'].reward = float(2)
           except:
               continue

       if abbreviation == 'lky':
	   try:
	       fullstr = prestr + "difficulty of " + coins['lky'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://explorer.luckycoinfoundation.org:49917/chain/luckycoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['lky'].div = simplejson.load(f)
	       coins['lky'].div = float(coins['lky'].div)
	       coins['lky'].reward = float(44)
           except:
               continue

       if abbreviation == 'gld':
	   try:
	       fullstr = prestr + "difficulty of " + coins['gld'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://gld.cryptocoinexplorer.com/chain/Goldcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['gld'].div = simplejson.load(f)
	       coins['gld'].div = float(coins['gld'].div)
	       coins['gld'].reward = float(45)
           except:
               continue

       if abbreviation == 'csc':
	   try:
	       fullstr = prestr + "difficulty of " + coins['csc'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://casinocoin.mooo.com/chain/CasinoCoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['csc'].div = simplejson.load(f)
	       coins['csc'].div = float(coins['csc'].div)
	       coins['csc'].reward = float(50)
           except:
               continue

       if abbreviation == 'dmd':
	   try:
	       fullstr = prestr + "difficulty of " + coins['dmd'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://www.diamondblocks.info/chain/Diamond/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['dmd'].div = simplejson.load(f)
	       coins['dmd'].div = float(coins['dmd'].div)
	       coins['dmd'].reward = float(1)
           except:
               continue

       if abbreviation == 'cat':
	   try:
	       fullstr = prestr + "difficulty of " + coins['cat'].name
               print fullstr + (79-len(fullstr))*" " + "\r",
	       req = urllib2.Request('http://catchain.info/chain/Catcoin/q/getdifficulty')
	       opener_cyp = urllib2.build_opener()
	       f = opener_cyp.open(req, timeout = 15)
 	       coins['cat'].div = simplejson.load(f)
	       coins['cat'].div = float(coins['cat'].div)
	       coins['cat'].reward = float(50)
           except:
               continue

       if abbreviation=='btc':
               coins['btc'].ratio=100.0
               coins['btc'].source = '--'
               coins['btc'].algo = "SHA-256"
               coins['btc'].price = 1.0
               success = 1
               break      


#calculating profitability
       if coins[abbreviation].price!=0.0:
                coins[abbreviation].ratio = (coins[abbreviation].reward/coins[abbreviation].div)/(coins['btc'].reward/coins['btc'].div)*coins[abbreviation].price*100/(1350000/1450)
# Now find the best profit coin
    bestcoin = 'btc'
    bestprof = 0
    print "comparing profitabilty..."
    print "-"*69           
    for abbreviation, c in coins.items():
        if extout == True:
                 print "%11s Price(BTC):%.8f Reward:%.2f diff:%.2f Profit:%.0f" % (coins[abbreviation].name, coins[abbreviation].price, coins[abbreviation].reward, coins[abbreviation].div, c.ratio),
     
        
                 print ""
     		 
        if c.ratio > bestprof and c.willingToMine:
                 bestcoin = abbreviation
                 bestprof = c.ratio

    print "-"*69         
    print "=> Best: %d, mining %s" % (bestprof, coins[bestcoin].name)
    coins[bestcoin].median = (coins[bestcoin].median * coins[bestcoin].cnt) + bestprof / (coins[bestcoin].cnt+1)
    coins[bestcoin].cnt = coins[bestcoin].cnt+1            

    if coins[bestcoin].miningNow == False:
        # i.e. if we're not already mining the best coin
        print '=> Switching to %s (running %s)' % (coins[bestcoin].name, coins[bestcoin].command)
        for abbreviation, c in coins.items():
            c.miningNow = False
        coins[bestcoin].miningNow = True
        subprocess.Popen(coins[bestcoin].command)

       
    print 'Work done for now... going back to sleep...:-)'
    i=0 
    while i<idletime*60:
        print "Seconds remaining:", (idletime*60-i), " ", "\r",
        time.sleep(1)
        i+=1

Code:

####################################################
# Altcoin Switcher Config File                     #
#                                                  #
# thx to area for his CryptoSwitcher without his   #
# coding style i would have not started playing    #  
# around with python                               #
# will send ya some donation                       #
# TipJar (BTC): 1H6L4VjrmRizXLLbrKLJQyx7vg87ZLjubD #
# Author: minime                                   #
####################################################


################################################################################
[MineCoins]

# Enable the coins you want to mine here.
mine42 = False
mineLEAF = True
mineDGC = True
mineTAG = False
mineNOBL = False
mineKDC = False
mineCON = False
mineUSDE = False
mineGLC = True
mineDGB = True
mineLOT = True
mineEAC = True
mineARG = True
mineBQC = True
mineDOGE = True
mineFRK = True
mineANC = True
mineFTC = True
mineCNC = True
mineMEC = False
mineLTC = True
mineWDC = True
mineMNC = True
minePHS = True
mineCMC = True
mineSBC = False
mineFST = True
mineELC = True
mineCRC = True
mineLKY = True
mineGLD = True
mineCSC = True
mineDMD = False
mineCAT = False
mineNVC = False
mineBTB = False
mineGDC = False
################################################################################
[Scripts]

# You should have scripts that stop all other forms of mining, set all necesary
#  environment variables, and start mining the appropriate coin.

# Examples included are 'litecoin.sh.sample' and 'bitcoin.sh.sample'.
# Any coins you aren't mining you can just leave blank.
# For Windows you can use bat-files, eg "BTCscript = bitcoin.bat".
PHSscript = ./phillostone.sh
AMCscript = ./americacoin.sh
ANCscript = ./anoncoin.sh 
BQCscript = ./bqc.sh
BTBscript = #
BTGscript = ./bitgem.sh 
CNCscript = ./CHNcoin.sh
CRCscript = ./craftcoin.sh 
ELCscript = ./elacoin.sh
FRKscript = ./franko.sh
FSTscript = ./fastcoin.sh
FTCscript = ./feathercoin.sh
GDCscript = ./grandcoin.sh
GLDscript = ./goldcoin.sh
LKYscript = ./luckycoin.sh
LTCscript = ./litecoin.sh
MECscript = #
MNCscript = ./mincoin.sh
DOGEscript = ./dogcoin.sh
SBCscript = #
WDCscript = ./worldcoin.sh
TAGscript = ./tagcoin.sh
ARGscript = ./argentum.sh
STRscript = ./startcoin.sh
LEAFscript = ./leafcoin.sh
DGCscript = ./digitalcoin.sh
GLCscript = ./globalcoin.sh
LOTscript = ./lottocoin.sh
EACscript = ./earthcoin.sh
DMDscript = #
CATscript = #
CSCscript = ./casinocoin.sh

42script = ./42coin.sh

DGBscript = ./dgbcoin.sh
NOBLscript = ./noblcoin.sh
KDCscript = ./KDCcoin.sh
CONscript = ./concoin.sh
USDEscript = ./usdecoin.sh
SMCscript = ./smscoin.sh

################################################################################
[Misc]

# Idle Time (in minutes) between two checks of coin profitability.
idletime = 5

# Gigahash per second you can output doing normal BTC mining.
ghashpersec = 0.7

# Gigakeys per second you can output doing vanity address mining.
gkeypersec = 0.05

# Trade multiplier - if not 1, sells not at the highest bid, but at this
#  multiple of it.  
tradeMultiplier = 1.02

# make sure our sell order is the lowest if tradeMultiplier > 1
tradeMultiplierCheck = False


################################################################################

Code:

#!/bin/bash
#Replace this script with one of your own.

#Send the quit command to any cgminer instances running
echo "{\"command\":\"quit\"}" | pkill -9 -f mining.py
#Set clocks
export DISPLAY=:0
screen -dmS cgm ./mining.py -pa scrypt -o gigahash.wemineltc.com -p 3333 -cu minime -cp xxxx -sp 6666 -gp 8888

mining.py is der stratum proxy..