def __init__(self, user_agent):

self.unset_credentials()

self.__headers = {

"User-Agent": user_agent

}

def get_username(self):

return self.__credentials[1] if self.have_credentials() else None

def have_credentials(self):

return self.__credentials != None

def set_credentials(self, exchange, username, password):

if len(exchange) == 0 or exchange == "mtgox":

exchange = "mtgox"

self.server = "mtgox.com"

self.__exchangename = "Mt. Gox"

self.__promptserver = "mtgox"

self.__commission = Decimal("0.0065")

self.__url_parts = urlparse.urlsplit("https://"+self.server)

self.actions = {"_get_ticker": "/code/data/ticker.php",

"get_depth": "/code/data/getDepth.php",

"get_trades": "/code/data/getTrades.php",

"get_balance": "/code/getFunds.php",

"buy_btc": "/code/buyBTC.php",

"sell_btc": "/code/sellBTC.php",

"_get_orders": "/code/getOrders.php",

"_cancel_order": "/code/cancelOrder.php",

"_withdraw": "/code/withdraw.php"}

if exchange == "exchb":

self.server = "www.exchangebitcoins.com"

self.__exchangename = "Exchange Bitcoins"

self.__promptserver = "exchb"

self.__commission = Decimal("0.0029")

self.__url_parts = urlparse.urlsplit("https://"+self.server)

self.actions = {"_get_ticker": "/data/ticker",

"get_depth": "/data/depth",

"get_trades": "/data/recent",

"get_balance": "/data/getFunds",

"buy_btc": "/data/buyBTC",

"sell_btc": "/data/sellBTC",

"_get_orders": "/data/getOrders",

"_cancel_order": "/data/cancelOrder"}

if len(username) == 0:

raise ValueError(u"Empty username.")

if len(password) == 0:

raise ValueError(u"Empty password.")

self.__credentials = (exchange, username, password)

def unset_credentials(self):

self.server = "mtgox.com"

self.__credentials = None

def get_servername(self):

return "@" + self.__promptserver if self.have_credentials() else None

def get_exchangename(self):

return self.__exchangename

def get_commission(self):

return self.__commission

def buy(self, amount, price):

return self.__get_json(self.actions["buy_btc"], params = {

u"amount": amount,

u"price": price

})

def cancel_order(self, kind, oid):

return self.__get_json(self.actions["_cancel_order"], params = {

u"oid": oid,

u"type": kind

})[u"orders"]

def get_balance(self):

return self.__get_json(self.actions["get_balance"])

def get_orders(self):

return self.__get_json(self.actions["_get_orders"])[u"orders"]

def get_ticker(self):

return self.__get_json(self.actions["_get_ticker"], auth = False)[u"ticker"]

def sell(self, amount, price):

return self.__get_json(self.actions["sell_btc"], params = {

u"amount": amount,

u"price": price

})

def withdraw(self, address, amount):

return self.__get_json(self.actions["_withdraw"], params = {

u"group1": u"BTC",

u"btca": address,

u"amount": amount

})

def __get_json(self, rel_path, params = {}, auth = True):

if auth and not self.have_credentials():

raise NoCredentialsError()

params = params.items()

if auth:

params += [

(u"name", self.__credentials[1]),

(u"pass", self.__credentials[2])

]

post_data = urllib.urlencode(params) if len(params) > 0 else None

url = urlparse.urlunsplit((

self.__url_parts.scheme,

self.__url_parts.netloc,

self.__url_parts.path + rel_path,

self.__url_parts.query,

self.__url_parts.fragment

))

req = urllib2.Request(url, post_data, self.__headers)

with closing(urllib2.urlopen(req, post_data)) as res:

data = json.load(res)

if u"error" in data:

if data[u"error"] == u"Not logged in.":

raise LoginError()

else:

raise MtGoxError(data[u"error"])

else:

def __init__(self, mtgox, encoding):

self.__mtgox = mtgox

self.__encoding = encoding

readline.parse_and_bind("tab: complete")

readline.set_completer(self.__complete)

self.__btc_precision = Decimal("0.00000001")

self.__usd_precision = Decimal("0.00001")

self.__usd_re = re.compile(r"^\$(\d*\.?\d+)$")

#self.__mtgox_commission = mtgox.get_commission()

def prompt(self):

proc = None

args = []

try:

try:

text = u"%s%s$ " % (self.__mtgox.get_username() or u"", self.__mtgox.get_servername() or u"")

line = raw_input(text).decode(self.__encoding).replace("@"," ").split()

if line:

cmd, args = line[0], line[1:]

proc = self.__get_cmd_proc(cmd, self.__unknown(cmd))

except EOFError, e:

print u"exit"

proc = self.__cmd_exit__

if proc != None:

(min_arity, max_arity) = self.__get_proc_arity(proc)

arg_count = len(args)

if min_arity <= arg_count and (max_arity == None or arg_count <= max_arity):

proc(*args)

else:

if min_arity == max_arity:

arity_text = unicode(min_arity)

elif max_arity == None:

arity_text = u"%s+" % min_arity

else:

arity_text = u"%s-%s" % (min_arity, max_arity)

arg_text = u"argument" + (u"" if arity_text == u"1" else u"s")

raise ArityError(u"Expected %s %s, got %s" % (arity_text, arg_text, arg_count))

except MtGoxError, e:

print "%s error: %s" % (e, self_mtgox.get_exchangename())

except EOFError, e:

raise e

except CommandError, e:

print e

except ArityError, e:

print e

except NoCredentialsError:

print u"No login credentials entered. Use the login command first."

except LoginError:

print u"%s rejected the login credentials. Maybe you made a typo?" % self.__mtgox.get_exchangename()

except KeyboardInterrupt:

print

except Exception, e:

traceback.print_exc()

def __get_cmd_proc(self, cmd, default = None):

return getattr(self, "__cmd_%s__" % cmd, default)

def __cmd_name(self, attr):

match = re.match(r"^__cmd_(.+)__$", attr)

return match.group(1) if match != None else None

def __get_cmds(self, prefix = ""):

return sorted(

filter(

lambda cmd: cmd != None and cmd.startswith(prefix),

(self.__cmd_name(attr) for attr in dir(self))

)

)

def __print_cmd_info(self, cmd):

proc = self.__get_cmd_proc(cmd)

if proc != None:

print cmd,

argspec = inspect.getargspec(proc)

args = argspec.args[1:]

if argspec.defaults != None:

i = -1

for default in reversed(argspec.defaults):

args[i] = (args[i], default)

i -= 1

for arg in args:

if not isinstance(arg, tuple):

print arg,

elif arg[1]:

print u"[%s=%s]" % arg,

else:

print u"[%s]" % arg[0],

if argspec.varargs != None:

print u"[...]",

print

doc = proc.__doc__ or u"--"

for line in doc.splitlines():

print " " + line

else:

self.__unknown(cmd)

def __get_proc_arity(self, proc):

argspec = inspect.getargspec(proc)

maximum = len(argspec.args[1:])

minimum = maximum - (len(argspec.defaults) if argspec.defaults != None else 0)

if argspec.varargs != None:

maximum = None

return (minimum, maximum)

def __complete(self, text, state):

cmds = self.__get_cmds(text)

try:

return self.__get_cmds(text)[state] + (" " if len(cmds) == 1 else "")

except IndexError:

return None

def __exchange(self, proc, amount, price):

match = self.__usd_re.match(amount)

if match:

usd_amount = Decimal(match.group(1))

btc_amount = str((usd_amount / Decimal(price)).quantize(self.__btc_precision))

else:

btc_amount = amount

ex_result = proc(btc_amount, price)

statuses = filter(None, ex_result[u"status"].split(u"<br>"))

for status in statuses:

print status

for order in ex_result[u"orders"]:

self.__print_order(order)

def __print_balance(self, balance):

print u"BTC:", balance[u"btcs"]

print u"USD:", balance[u"usds"]

def __print_order(self, order):

kind = {1: u"sell", 2: u"buy", u"Sell": u"sell", u"Buy": u"buy"}[order[u"type"]]

timestamp = datetime.fromtimestamp(int(order[u"date"])).strftime("%Y-%m-%d %H:%M:%S")

properties = []

if u"dark" in order and bool(int(order[u"dark"])):

properties.append(u"dark")

if u"status" in order and order[u"status"] == u"2":

properties.append(u"not enough funds")

print "[%s] %s %s: %sBTC @ %sUSD%s" % (timestamp, kind, order[u"oid"], order[u"amount"], order[u"price"], (" (" + ", ".join(properties) + ")" if properties else ""))

def __unknown(self, cmd):

def __unknown_1(*args):

print u"%s: Unknown command." % cmd

return __unknown_1

def __cmd_balance__(self):

u"Display account balance."

self.__print_balance(self.__mtgox.get_balance())

def __cmd_buy__(self, amount, price):

u"Buy bitcoins.\nPrefix the amount with a '$' to spend that many USD and calculate BTC amount\nautomatically."

self.__exchange(self.__mtgox.buy, amount, price)

def __cmd_cancel__(self, kind, order_id):

u"Cancel the order with the specified kind (buy or sell) and order ID."

try:

num_kind = {u"sell": 1, u"buy": 2, u"Sell": 1, u"Buy": 2}[kind]

orders = self.__mtgox.cancel_order(num_kind, order_id)

print u"Canceled %s %s." % (kind, order_id)

if orders:

for order in orders:

self.__print_order(order)

else:

print u"No remaining orders."

except KeyError:

raise CommandError(u"%s: Invalid order kind." % kind)

def __cmd_exit__(self):

u"Exit goxsh."

raise EOFError()

def __cmd_help__(self, command = None):

u"Show help for the specified command or list all commands if none is given."

if command == None:

cmds = self.__get_cmds()

else:

cmds = [command]

for cmd in cmds:

self.__print_cmd_info(cmd)

def __cmd_login__(self, username = u"", exchange = u"mtgox"):

u"Set login credentials. Exchange can be either mtgox or exchb."

if not username:

while not username:

username = raw_input(u"Username: ").decode(self.__encoding)

readline.remove_history_item(readline.get_current_history_length() - 1)

password = u""

while not password:

password = getpass.getpass()

self.__mtgox.set_credentials(exchange, username, password)

self.__mtgox_commission = self.__mtgox.get_commission()

def __cmd_logout__(self):

u"Unset login credentials."

self.__mtgox.unset_credentials()

def __cmd_orders__(self, kind = None):

u"List open orders.\nSpecifying a kind (buy or sell) will list only orders of that kind."

try:

num_kind = {None: None, u"sell": 1, u"buy": 2, u"Sell": 1, u"Buy": 2}[kind]

orders = self.__mtgox.get_orders()

if orders:

for order in orders:

if num_kind in (None, order[u"type"]):

self.__print_order(order)

else:

print u"No orders."

except KeyError:

raise CommandError(u"%s: Invalid order kind." % kind)

def __cmd_profit__(self, price):

u"Calculate profitable short/long prices for a given initial price, taking\ninto account the exchange's commission fee."

if not self.__mtgox.have_credentials():

raise CommandError(u"You must login to an exchange first.")

try:

dec_price = Decimal(price)

if dec_price < 0:

raise CommandError(u"%s: Invalid price." % price)

min_profitable_ratio = (1 - self.__mtgox_commission)**(-2)

print u"Short: < %s" % (dec_price / min_profitable_ratio).quantize(self.__usd_precision, ROUND_DOWN)

print u"Long: > %s" % (dec_price * min_profitable_ratio).quantize(self.__usd_precision, ROUND_UP)

except InvalidOperation:

raise CommandError(u"%s: Invalid price." % price)

def __cmd_sell__(self, amount, price):

u"Sell bitcoins.\nPrefix the amount with a '$' to receive that many USD and calculate BTC\namount automatically."

self.__exchange(self.__mtgox.sell, amount, price)

def __cmd_ticker__(self):

u"Display ticker."

ticker = self.__mtgox.get_ticker()

print u"Last: %s" % ticker[u"last"]

print u"Buy: %s" % ticker[u"buy"]

print u"Sell: %s" % ticker[u"sell"]

print u"High: %s" % ticker[u"high"]

print u"Low: %s" % ticker[u"low"]

print u"Volume: %s" % ticker[u"vol"]

def __cmd_withdraw__(self, address, amount):

u"Withdraw bitcoins."

withdraw_info = self.__mtgox.withdraw(address, amount)

print withdraw_info[u"status"]

print u"Updated balance:"

locale.setlocale(locale.LC_ALL, "")

encoding = locale.getpreferredencoding()

sh = GoxSh(MtGox(u"goxsh"), encoding)

print u"Welcome to goxsh!"

print u"Type 'help' to get started."

try:

while True:

sh.prompt()

except EOFError: