487 lines
15 KiB
Python
487 lines
15 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Copyright (C) 2009 Tan Swee Heng
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
|
|
"""Contains extensions to Atom objects used with Google Finance."""
|
|
|
|
|
|
__author__ = 'thesweeheng@gmail.com'
|
|
|
|
|
|
import atom
|
|
import gdata
|
|
|
|
|
|
GD_NAMESPACE = 'http://schemas.google.com/g/2005'
|
|
GF_NAMESPACE = 'http://schemas.google.com/finance/2007'
|
|
|
|
|
|
class Money(atom.AtomBase):
|
|
"""The <gd:money> element."""
|
|
_tag = 'money'
|
|
_namespace = GD_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['amount'] = 'amount'
|
|
_attributes['currencyCode'] = 'currency_code'
|
|
|
|
def __init__(self, amount=None, currency_code=None, **kwargs):
|
|
self.amount = amount
|
|
self.currency_code = currency_code
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
def __str__(self):
|
|
return "%s %s" % (self.amount, self.currency_code)
|
|
|
|
|
|
def MoneyFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(Money, xml_string)
|
|
|
|
|
|
class _Monies(atom.AtomBase):
|
|
"""An element containing multiple <gd:money> in multiple currencies."""
|
|
_namespace = GF_NAMESPACE
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}money' % GD_NAMESPACE] = ('money', [Money])
|
|
|
|
def __init__(self, money=None, **kwargs):
|
|
self.money = money or []
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
def __str__(self):
|
|
return " / ".join(["%s" % i for i in self.money])
|
|
|
|
|
|
class CostBasis(_Monies):
|
|
"""The <gf:costBasis> element."""
|
|
_tag = 'costBasis'
|
|
|
|
|
|
def CostBasisFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(CostBasis, xml_string)
|
|
|
|
|
|
class DaysGain(_Monies):
|
|
"""The <gf:daysGain> element."""
|
|
_tag = 'daysGain'
|
|
|
|
|
|
def DaysGainFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(DaysGain, xml_string)
|
|
|
|
|
|
class Gain(_Monies):
|
|
"""The <gf:gain> element."""
|
|
_tag = 'gain'
|
|
|
|
|
|
def GainFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(Gain, xml_string)
|
|
|
|
|
|
class MarketValue(_Monies):
|
|
"""The <gf:marketValue> element."""
|
|
_tag = 'gain'
|
|
_tag = 'marketValue'
|
|
|
|
|
|
def MarketValueFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(MarketValue, xml_string)
|
|
|
|
|
|
class Commission(_Monies):
|
|
"""The <gf:commission> element."""
|
|
_tag = 'commission'
|
|
|
|
|
|
def CommissionFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(Commission, xml_string)
|
|
|
|
|
|
class Price(_Monies):
|
|
"""The <gf:price> element."""
|
|
_tag = 'price'
|
|
|
|
|
|
def PriceFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(Price, xml_string)
|
|
|
|
|
|
class Symbol(atom.AtomBase):
|
|
"""The <gf:symbol> element."""
|
|
_tag = 'symbol'
|
|
_namespace = GF_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['fullName'] = 'full_name'
|
|
_attributes['exchange'] = 'exchange'
|
|
_attributes['symbol'] = 'symbol'
|
|
|
|
def __init__(self, full_name=None, exchange=None, symbol=None, **kwargs):
|
|
self.full_name = full_name
|
|
self.exchange = exchange
|
|
self.symbol = symbol
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
def __str__(self):
|
|
return "%s:%s (%s)" % (self.exchange, self.symbol, self.full_name)
|
|
|
|
|
|
def SymbolFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(Symbol, xml_string)
|
|
|
|
|
|
class TransactionData(atom.AtomBase):
|
|
"""The <gf:transactionData> element."""
|
|
_tag = 'transactionData'
|
|
_namespace = GF_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['type'] = 'type'
|
|
_attributes['date'] = 'date'
|
|
_attributes['shares'] = 'shares'
|
|
_attributes['notes'] = 'notes'
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}commission' % GF_NAMESPACE] = ('commission', Commission)
|
|
_children['{%s}price' % GF_NAMESPACE] = ('price', Price)
|
|
|
|
def __init__(self, type=None, date=None, shares=None,
|
|
notes=None, commission=None, price=None, **kwargs):
|
|
self.type = type
|
|
self.date = date
|
|
self.shares = shares
|
|
self.notes = notes
|
|
self.commission = commission
|
|
self.price = price
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
|
|
def TransactionDataFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(TransactionData, xml_string)
|
|
|
|
|
|
class TransactionEntry(gdata.GDataEntry):
|
|
"""An entry of the transaction feed.
|
|
|
|
A TransactionEntry contains TransactionData such as the transaction
|
|
type (Buy, Sell, Sell Short, or Buy to Cover), the number of units,
|
|
the date, the price, any commission, and any notes.
|
|
"""
|
|
_tag = 'entry'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataEntry._children.copy()
|
|
_children['{%s}transactionData' % GF_NAMESPACE] = (
|
|
'transaction_data', TransactionData)
|
|
|
|
def __init__(self, transaction_data=None, **kwargs):
|
|
self.transaction_data = transaction_data
|
|
gdata.GDataEntry.__init__(self, **kwargs)
|
|
|
|
def transaction_id(self):
|
|
return self.id.text.split("/")[-1]
|
|
|
|
transaction_id = property(transaction_id, doc='The transaction ID.')
|
|
|
|
|
|
def TransactionEntryFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(TransactionEntry, xml_string)
|
|
|
|
|
|
class TransactionFeed(gdata.GDataFeed):
|
|
"""A feed that lists all of the transactions that have been recorded for
|
|
a particular position.
|
|
|
|
A transaction is a collection of information about an instance of
|
|
buying or selling a particular security. The TransactionFeed lists all
|
|
of the transactions that have been recorded for a particular position
|
|
as a list of TransactionEntries.
|
|
"""
|
|
_tag = 'feed'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataFeed._children.copy()
|
|
_children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [TransactionEntry])
|
|
|
|
|
|
def TransactionFeedFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(TransactionFeed, xml_string)
|
|
|
|
|
|
class TransactionFeedLink(atom.AtomBase):
|
|
"""Link to TransactionFeed embedded in PositionEntry.
|
|
|
|
If a PositionFeed is queried with transactions='true', TransactionFeeds
|
|
are inlined in the returned PositionEntries. These TransactionFeeds are
|
|
accessible via TransactionFeedLink's feed attribute.
|
|
"""
|
|
_tag = 'feedLink'
|
|
_namespace = GD_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['href'] = 'href'
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}feed' % atom.ATOM_NAMESPACE] = (
|
|
'feed', TransactionFeed)
|
|
|
|
def __init__(self, href=None, feed=None, **kwargs):
|
|
self.href = href
|
|
self.feed = feed
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
|
|
class PositionData(atom.AtomBase):
|
|
"""The <gf:positionData> element."""
|
|
_tag = 'positionData'
|
|
_namespace = GF_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['gainPercentage'] = 'gain_percentage'
|
|
_attributes['return1w'] = 'return1w'
|
|
_attributes['return4w'] = 'return4w'
|
|
_attributes['return3m'] = 'return3m'
|
|
_attributes['returnYTD'] = 'returnYTD'
|
|
_attributes['return1y'] = 'return1y'
|
|
_attributes['return3y'] = 'return3y'
|
|
_attributes['return5y'] = 'return5y'
|
|
_attributes['returnOverall'] = 'return_overall'
|
|
_attributes['shares'] = 'shares'
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}costBasis' % GF_NAMESPACE] = ('cost_basis', CostBasis)
|
|
_children['{%s}daysGain' % GF_NAMESPACE] = ('days_gain', DaysGain)
|
|
_children['{%s}gain' % GF_NAMESPACE] = ('gain', Gain)
|
|
_children['{%s}marketValue' % GF_NAMESPACE] = ('market_value', MarketValue)
|
|
|
|
def __init__(self, gain_percentage=None,
|
|
return1w=None, return4w=None, return3m=None, returnYTD=None,
|
|
return1y=None, return3y=None, return5y=None, return_overall=None,
|
|
shares=None, cost_basis=None, days_gain=None,
|
|
gain=None, market_value=None, **kwargs):
|
|
self.gain_percentage = gain_percentage
|
|
self.return1w = return1w
|
|
self.return4w = return4w
|
|
self.return3m = return3m
|
|
self.returnYTD = returnYTD
|
|
self.return1y = return1y
|
|
self.return3y = return3y
|
|
self.return5y = return5y
|
|
self.return_overall = return_overall
|
|
self.shares = shares
|
|
self.cost_basis = cost_basis
|
|
self.days_gain = days_gain
|
|
self.gain = gain
|
|
self.market_value = market_value
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
|
|
def PositionDataFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PositionData, xml_string)
|
|
|
|
|
|
class PositionEntry(gdata.GDataEntry):
|
|
"""An entry of the position feed.
|
|
|
|
A PositionEntry contains the ticker exchange and Symbol for a stock,
|
|
mutual fund, or other security, along with PositionData such as the
|
|
number of units of that security that the user holds, and performance
|
|
statistics.
|
|
"""
|
|
_tag = 'entry'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataEntry._children.copy()
|
|
_children['{%s}positionData' % GF_NAMESPACE] = (
|
|
'position_data', PositionData)
|
|
_children['{%s}symbol' % GF_NAMESPACE] = ('symbol', Symbol)
|
|
_children['{%s}feedLink' % GD_NAMESPACE] = (
|
|
'feed_link', TransactionFeedLink)
|
|
|
|
def __init__(self, position_data=None, symbol=None, feed_link=None,
|
|
**kwargs):
|
|
self.position_data = position_data
|
|
self.symbol = symbol
|
|
self.feed_link = feed_link
|
|
gdata.GDataEntry.__init__(self, **kwargs)
|
|
|
|
def position_title(self):
|
|
return self.title.text
|
|
|
|
position_title = property(position_title,
|
|
doc='The position title as a string (i.e. position.title.text).')
|
|
|
|
def ticker_id(self):
|
|
return self.id.text.split("/")[-1]
|
|
|
|
ticker_id = property(ticker_id, doc='The position TICKER ID.')
|
|
|
|
def transactions(self):
|
|
if self.feed_link.feed:
|
|
return self.feed_link.feed.entry
|
|
else:
|
|
return None
|
|
|
|
transactions = property(transactions, doc="""
|
|
Inlined TransactionEntries are returned if PositionFeed is queried
|
|
with transactions='true'.""")
|
|
|
|
|
|
def PositionEntryFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PositionEntry, xml_string)
|
|
|
|
|
|
class PositionFeed(gdata.GDataFeed):
|
|
"""A feed that lists all of the positions in a particular portfolio.
|
|
|
|
A position is a collection of information about a security that the
|
|
user holds. The PositionFeed lists all of the positions in a particular
|
|
portfolio as a list of PositionEntries.
|
|
"""
|
|
_tag = 'feed'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataFeed._children.copy()
|
|
_children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [PositionEntry])
|
|
|
|
|
|
def PositionFeedFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PositionFeed, xml_string)
|
|
|
|
|
|
class PositionFeedLink(atom.AtomBase):
|
|
"""Link to PositionFeed embedded in PortfolioEntry.
|
|
|
|
If a PortfolioFeed is queried with positions='true', the PositionFeeds
|
|
are inlined in the returned PortfolioEntries. These PositionFeeds are
|
|
accessible via PositionFeedLink's feed attribute.
|
|
"""
|
|
_tag = 'feedLink'
|
|
_namespace = GD_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['href'] = 'href'
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}feed' % atom.ATOM_NAMESPACE] = (
|
|
'feed', PositionFeed)
|
|
|
|
def __init__(self, href=None, feed=None, **kwargs):
|
|
self.href = href
|
|
self.feed = feed
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
|
|
class PortfolioData(atom.AtomBase):
|
|
"""The <gf:portfolioData> element."""
|
|
_tag = 'portfolioData'
|
|
_namespace = GF_NAMESPACE
|
|
_attributes = atom.AtomBase._attributes.copy()
|
|
_attributes['currencyCode'] = 'currency_code'
|
|
_attributes['gainPercentage'] = 'gain_percentage'
|
|
_attributes['return1w'] = 'return1w'
|
|
_attributes['return4w'] = 'return4w'
|
|
_attributes['return3m'] = 'return3m'
|
|
_attributes['returnYTD'] = 'returnYTD'
|
|
_attributes['return1y'] = 'return1y'
|
|
_attributes['return3y'] = 'return3y'
|
|
_attributes['return5y'] = 'return5y'
|
|
_attributes['returnOverall'] = 'return_overall'
|
|
_children = atom.AtomBase._children.copy()
|
|
_children['{%s}costBasis' % GF_NAMESPACE] = ('cost_basis', CostBasis)
|
|
_children['{%s}daysGain' % GF_NAMESPACE] = ('days_gain', DaysGain)
|
|
_children['{%s}gain' % GF_NAMESPACE] = ('gain', Gain)
|
|
_children['{%s}marketValue' % GF_NAMESPACE] = ('market_value', MarketValue)
|
|
|
|
def __init__(self, currency_code=None, gain_percentage=None,
|
|
return1w=None, return4w=None, return3m=None, returnYTD=None,
|
|
return1y=None, return3y=None, return5y=None, return_overall=None,
|
|
cost_basis=None, days_gain=None, gain=None, market_value=None, **kwargs):
|
|
self.currency_code = currency_code
|
|
self.gain_percentage = gain_percentage
|
|
self.return1w = return1w
|
|
self.return4w = return4w
|
|
self.return3m = return3m
|
|
self.returnYTD = returnYTD
|
|
self.return1y = return1y
|
|
self.return3y = return3y
|
|
self.return5y = return5y
|
|
self.return_overall = return_overall
|
|
self.cost_basis = cost_basis
|
|
self.days_gain = days_gain
|
|
self.gain = gain
|
|
self.market_value = market_value
|
|
atom.AtomBase.__init__(self, **kwargs)
|
|
|
|
|
|
def PortfolioDataFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PortfolioData, xml_string)
|
|
|
|
|
|
class PortfolioEntry(gdata.GDataEntry):
|
|
"""An entry of the PortfolioFeed.
|
|
|
|
A PortfolioEntry contains the portfolio's title along with PortfolioData
|
|
such as currency, total market value, and overall performance statistics.
|
|
"""
|
|
_tag = 'entry'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataEntry._children.copy()
|
|
_children['{%s}portfolioData' % GF_NAMESPACE] = (
|
|
'portfolio_data', PortfolioData)
|
|
_children['{%s}feedLink' % GD_NAMESPACE] = (
|
|
'feed_link', PositionFeedLink)
|
|
|
|
def __init__(self, portfolio_data=None, feed_link=None, **kwargs):
|
|
self.portfolio_data = portfolio_data
|
|
self.feed_link = feed_link
|
|
gdata.GDataEntry.__init__(self, **kwargs)
|
|
|
|
def portfolio_title(self):
|
|
return self.title.text
|
|
|
|
def set_portfolio_title(self, portfolio_title):
|
|
self.title = atom.Title(text=portfolio_title, title_type='text')
|
|
|
|
portfolio_title = property(portfolio_title, set_portfolio_title,
|
|
doc='The portfolio title as a string (i.e. portfolio.title.text).')
|
|
|
|
def portfolio_id(self):
|
|
return self.id.text.split("/")[-1]
|
|
|
|
portfolio_id = property(portfolio_id,
|
|
doc='The portfolio ID. Do not confuse with portfolio.id.')
|
|
|
|
def positions(self):
|
|
if self.feed_link.feed:
|
|
return self.feed_link.feed.entry
|
|
else:
|
|
return None
|
|
|
|
positions = property(positions, doc="""
|
|
Inlined PositionEntries are returned if PortfolioFeed was queried
|
|
with positions='true'.""")
|
|
|
|
|
|
def PortfolioEntryFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PortfolioEntry, xml_string)
|
|
|
|
|
|
class PortfolioFeed(gdata.GDataFeed):
|
|
"""A feed that lists all of the user's portfolios.
|
|
|
|
A portfolio is a collection of positions that the user holds in various
|
|
securities, plus metadata. The PortfolioFeed lists all of the user's
|
|
portfolios as a list of PortfolioEntries.
|
|
"""
|
|
_tag = 'feed'
|
|
_namespace = atom.ATOM_NAMESPACE
|
|
_children = gdata.GDataFeed._children.copy()
|
|
_children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [PortfolioEntry])
|
|
|
|
|
|
def PortfolioFeedFromString(xml_string):
|
|
return atom.CreateClassFromXMLString(PortfolioFeed, xml_string)
|
|
|
|
|