DictionaryStocks.py

Go to the documentation of this file.

## @package serverportfolio.DictionaryStocks
#
# Define singleton class @ref serverportfolio.DictionaryStocks.DictionaryStocks "DictionaryStocks",
# act as the main container of Stocks objects.
#
# Last Changed $Id: DictionaryStocks.py 13 2015-04-12 19:45:14Z michael $

# why not use singleton
# http://stackoverflow.com/questions/6760685/creating-a-singleton-in-python
# http://c2.com/cgi/wiki?PythonSingleton

# trick for python package, seems obsolete
# http://stackoverflow.com/questions/6654951/doxygen-chokes-on-init-py-files

import os, re, types, logging
import traceback
import time, datetime

# solved bug, unit_test can change the global variable DICT_PATH
# from serverportfolio.GlobalDicts import *
import serverportfolio.GlobalDicts as GlobalDicts

from serverportfolio import Utils
from serverportfolio.PortfolioException import PortfolioError, ParserError
from serverportfolio.StockTemplates import StTmpl
from serverportfolio.Stock import Stock, InvalidStock
from serverportfolio.ModClientTCP import TCPClient

# to put in class, for extending with portfolio
# save the name of the dictionary, in case of multiple dictionary.txt
# set up when called the first time, used when a reload is needed
# name_dict = None

## @class Singleton
# @brief Define a metaclass Singleton object.
#
# @note Due to the naming convention in python, a "main" cannot be run inside the same file.\n
# The object will be named main.DictionaryStocks inside the file, and a different instance would be created by other modules.\n
# @note See unit-test for _drop() function in order to "delete" a Singleton.
class Singleton(type):
    _instances = {}

    ## @brief Executed at the object creation, created only once. Then return the saved instance.
    def __call__(cls, *args, **kwargs):
        #print "cls._instances ", cls._instances
        if cls not in cls._instances:
            # better here, should be created only once
            cls.logger=logging.getLogger("SP.Singleton")
            cls.logger.debug("create new instance singleton")
            # call DictStocks.__init__()
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        else:
            cls.logger.debug("return already created instance")
        return cls._instances[cls]

# note python 3 would be
#class MyClass(BaseClass, metaclass=Singleton):

## @class DictionaryStocks
# @brief Container of all Stocks objects, it also reads the static stocks configuration file "dictstocks.txt"
#
# It is a singleton object, responsible of:
#   - reading static definition in the configuration file
#   - the Stock objects creation, initialisation and destruction
#   - the connection to the GUIServer (in ROOT_application)
#
# The singleton will be normally initialized at its first use (with the reading of the Static stocks data).\n  
# The Stock objects are then initialised on demand by calls to get_stocks()\n
#
# To force the initialisation of all the stocks in the configuration file, one must call explicitely the constructor:
# @code DictionaryStocks.DictionaryStocks(load_all_stock=True) @endcode
#
# Functionalities:
#   - print stock data to screen
#   - send new data to the GUIServer
#
# The container is basically implemented as a dictionary of Stock.
class DictionaryStocks( object ):
    ## @brief Define DictionaryStocks as a Singleton.
    # A call to DictionaryStocks() will always return the unique instance of the class
    __metaclass__ = Singleton

    ## @brief Initialise the singleton dictionary and read the configuration text file.
    #  
    # By default store the content of the stocks definition, but do not initialise the Stock objects.\n
    # These objects will be created on demand by calls to get_stocks().\n
    # The boolean option load_all_stocks will force to create and initialise all Stock present in the configuration file.  
    # @param file_stocks optional with default name 'dictstocks.txt'
    # @param  load_all_stocks if True will create and initialise all Stock objects.
    def __init__(self, file_stocks=GlobalDicts.DEFAULT_DICTIONARY, load_all_stocks = False):
        self.logger = logging.getLogger("SP.DictStocks")
        self.logger.debug("Init DictionaryStocks")
        
        ## @brief Dictionary containing Stock objects with key/value = 'symbol' : Stock object.
        # __getitem__ / __setitem__ are implemented to avoid a call to the private data member
        self._dictstocks={}
        
        ## @brief Store the content of the static stocks definitions (dictstocks.txt).
        # 'Static' data are ead from this configuration file and stored in the 'Static' template
        self._dictstocks_config={}
        
        ## @brief Store the name of the configuration file. 
        # The full path is created in the function _read_config_txt()\n
        # multiple configuration files not implemented yet
        self._file_stocks = file_stocks
        
        # read the definition of stocks, static data stored in _dictstocks_config
        try :
            list_stocks = self._read_config_txt( file_stocks )
        # wrong filename
        except PortfolioError:
            self.logger.error("Caught PortfolioError in _read_config_txt. Should not happen !")
            raise
        # other exception in parsing ?
        except Exception:
            self.logger.error("Catch Exception in _read_config_txt. Should not happen !")
            raise
   
        self.logger.debug("list of stocks loaded by configuration %s" % list_stocks)
        
        # If True all Stock objects will be created. 
        # Not necessary if only one query is needed, will be created later on demand.
        if load_all_stocks == True:
            self._create_stocks(stock_symbol=None)
        
        ## @brief Access to the TCPClient for sending update to the GUIServer. 
        # If data do not come back after an update, it should be done by Stock or Parser.\n
        # keep here is not bad, or independent singleton... but activated only if GUI or receive a message
        # @todo to re-implement, test functionalities
        self._tcp_client = TCPClient()
        # check the connection is possible, set activity 
        # self.tcp_client.active = self.tcp_client.Connect( only_check=True )

    ## @name Basic dictionary functionalities to access the Stock objects
    ## @{

    ## @brief Access by key.
    # return a Stock object, may be an InvalidStock if not present in the configuration file
    def __getitem__(self, item):

        if item in self._dictstocks: 
            return self._dictstocks[item]
        
        # create on demand, return only one stock (not a list)
        return self.get_stocks( item )

    ## @brief Set with key / value
    def __setitem__(self, key, value):
        assert isinstance(value,Stock), 'Only Stock object can be assigned'
        self._dictstocks[key] = value
    ## @}

#  #############  Getter/Setter functions, public interface, some to embed in C++ ##############

    ## @brief Return a Stock (or a list of Stock) object(s) from a symbol (or a list of symbols).
    # Initialise the Stock object if necessary.\n
    #
    # @post Always return the required stocks, maybe an InvalidStock\nNo exception but assert\n
    #
    # Return an InvalidStock if the stock symbol is not in the configuration file
    # @param input_stock a stock symbol or a list of symbols
    # @return a stock object or a list of stock objects (depends on input)
    def get_stocks(self, input_stock): # = None):
        self.logger.debug("get_stocks: %s" % input_stock)

        list_stock = Utils.to_list( input_stock )
        # list of objects to return
        list_obj_stock = []

        # test, stocks should be loaded only once, correct but not convenient
        #list_to_create = [symbol for symbol in list_stock if symbol not in self._dictstocks]
        #print "list_to_create ", list_to_create
        #self._create_stocks( list_to_create )

        for symbol in list_stock:
            # check if Stock already exists or need to be created
            if symbol not in self._dictstocks:
                # couple of asserts in _create_stocks
                self._create_stocks( symbol )

            # exist for sure, maybe InvalidStock
            list_obj_stock.append( self[symbol] )

        # return 1 object, not a list, if only one was asked in input
        if len(list_stock) == 1:
            return list_obj_stock[0]
        else:
            return list_obj_stock

# created for UpdateStocks get_data 
    ## @brief Return the list of stock symbols loaded from the configuration file, do not create the Stock objects.
    # @param all_stocks True : return all stocks read from the config file, False : only Stock in memory
    def get_stock_keys(self, all_stocks = False):
        self.logger.debug("get_stock_config.keys :%s", self._dictstocks_config.keys())
        if all_stocks == True:
            return self._dictstocks_config.keys()
        else:
            return self._dictstocks.keys()

    ## @brief Return the static template from a stock symbol.
    # If the symbol is not in the configuration file, the default Static template is returned
    # @param symbol of the stock
    def get_dict_static(self, symbol):
        if symbol in self._dictstocks_config:
            return self._dictstocks_config[symbol] #['Static'] after modifs in read_config
        # return default
        return StTmpl.get_template_stock('Static')

    ## @brief Print (a nice) output of the data.
    # Can print more than one stock.\n
    # If data have not been loaded or Stock is invalid, the format is: 'symbol ERROR error_message'
    # 
    # @param action type of data/EAction to return
    # @param input_stocks one stock(string) or list of stocks, default None to use with opt_all_stocks
    # @param opt_all_stocks print data from all stocks read in the configuration file, not only loaded as Stocks (InvalidStock do not appear)
    # @param opt_header add a header line to describe the data
    # @return a string with '\n' as separator
    def print_dict_stocks( self, action, input_stocks = None, opt_all_stocks = False, opt_header = False ):
        self.logger.debug("Entry print_dict_stocks, action: %s" % action )
        self.logger.debug("list stock: %s" % input_stocks)
        
        # all stocks in config file
        if opt_all_stocks == True:
            list_stock = self._dictstocks_config.keys()
        # only the stocks already loaded
        else :
            # default argument print all stocks in dictionary, include InvalidStock
            if input_stocks == None:
                list_stock = self._dictstocks.keys()
            # test if one element (string) or a list
            else :
                list_stock = Utils.to_list( input_stocks )
            
        # case of header, add a first line starting with '#'
        stock_lines = str()
        if opt_header:
            stock_lines += StTmpl.make_header(action)
        
        # create the line(s)    
        for stock in list_stock:
            # action argument specifies which template to use
            stock_lines += self.get_stocks(stock).print_stock( action )
            
        return stock_lines

#  #### to re-implement
#    # brief Send the instantaneous (maybe other later) data to the server_gui
#    def send_to_server_gui(self, list_stock):
#        if self._server_gui:

#  #############  private interface  ###########

    ## @brief Create and initialise Stock objects.
    # If stock_symbol = None, all stocks are loaded. Not good in public interface, ok if private.\n
    # Only called by DictionaryStock (with load_all_stocks = True)\n
    # If a symbol is wrong (not in the configuration file) an InvalidStock is created instead.
    #
    # @pre The stock(s) should be created only once(assert)
    # @post Return a valid list of Stock objects, maybe InvalidStock
    #
    # @todo in case of reload, should recreate the Stock(problem with threads) ?
    #
    # @param stock_symbol list of symbols to create, if None create all from the configuration file
    def _create_stocks(self, stock_symbol):
        # dangerous, if already stock loaded, and then call stock_symbol = None
        # problems later, if dictionary is reloaded
        if stock_symbol == None :
            self.logger.info("Load all Stocks from the configuration file")
            assert len(self._dictstocks) == 0, \
                    "Option stock_symbol = None, but dictionary not empty"
            list_symbol = self._dictstocks_config.keys()
        else :
            list_symbol = Utils.to_list( stock_symbol )

        for symbol in list_symbol:
            # not already loaded 
            assert symbol not in self._dictstocks, \
                    "Try to create an already loaded Stock"
            # check symbol exists, could overwrite symbol to Invalid but loose the wrong name
            #if not self._dictstocks_config.has_key(symbol):
            if symbol not in self._dictstocks_config:
                stock = InvalidStock( symbol, StTmpl.get_tmpl_static_invalid() )
            else :
                # Stock creation, set with static data 
                stock = Stock( symbol, self.get_dict_static( symbol ) )
            # insert the new stock in the dictionary, even if InvalidStock
            self[symbol] = stock

    ## @brief Read static definition of the stocks from the configuration text file.
    # It sets the static data key in the global StockTemplates.StTmpl from the header of dictstocks.txt\n
    # Then fill _dictstocks_config with Static stock template (config and template)
    # Use later for Stock creation\n
    #
    # @todo To implement: reload the file with new stocks or new parameters.
    #
    # @param file_stocks filename of the portfolio file, default "dictstocks.txt"
    # @throw PortfolioError if the file cannot be opened
    def _read_config_txt(self, file_stocks):
        self.logger.debug("read_config_txt file: %s" % file_stocks)
        # full path necessary when called from C++ with embedding of python code
        file_stocks = GlobalDicts.PATH_DICT + os.sep + self._file_stocks
        self.logger.debug("file_stocks: %s" % file_stocks)

        # check if global name_dict already setup, used for reload
        #if name_dict != None :
        #if self._file_stocks != None:
            #file_stocks = name_dict
        #    self._file_stocks = 
        #    self.logger.info("reload dictionary %s" % name_dict)
            #print "reload dictionary %s" % name_dict

        # first time setup, use default if needed
        #else :
        #    name_dict = file_stocks
        #    self.logger.info("load dictionary for the first time %s " % name_dict)
            #print "load dictionary for the first time %s" % name_dict

        try:
            self.logger.debug("open file %s" % file_stocks)
            file=open(file_stocks,"r")
        except :
            self.logger.error("file: %s cannot be opened, throw PortfolioError" % file_stocks )
            # throw a FileError would be cleaner, similar to C++ and can re-use 
            raise PortfolioError("Cannot open file: %s" % file_stocks)

        # read header, delete terminal \n
        line = file.readline()[:-1]
        # extract the key words from the header
        list_key = line.split()
        # delete first one : "##"
        list_key.pop(0)
        # This is the keys for static data
        self.logger.debug("list_key in config %s" % list_key)

        # set model StTmpl._tmpl_static, should be done only once, assert in StTmpl
        # pass the first element : symbol, will be the key
        StTmpl.set_tmpl_static( list_key[1:] )

        # if dictionary is reloaded, send back the list of new stocks
        list_new = []

        # with to be sure to close the file
        for line in file.readlines():
            # discard empty line, line.rsplit()
            if line == '\n' : #if line in ['\n', '\r\n']
                continue

            data=line.split()
            # escape commented line starting with "#"
            if data[0][0] == "#":
                continue

            # check if a new symbol is found, important if reload of data which already exists
            if data[0] not in self._dictstocks_config:

                # in case of reload only, add only the new symbol (not re-implemented)
                list_new.append(data[0])
                # get a copy of 'static','template'
                tmpl_static = StTmpl.get_template_stock('Static')
                # loop from 1, symbol will be the key
                for i in range(1,len(data)):
                    # Need to modify the value of 'market' for OpeningMarket
                    if list_key[i]=='market':
                        #print "market ", data[i]
                        data[i] = GlobalDicts.MarketMySQL_to_DictStock(data[i])

                    # previous code
                    #tmpl_static[ list_key[i] ] = data[i]
                    # new code, could be set_template('Static'), no...
                    tmpl_static['template'][ list_key[i] ] = data[i]

                # assign to dictstocks_config with symbol as keyword
                self._dictstocks_config[ data[0] ] = tmpl_static

        file.close()
        self.logger.debug("Dictionary Stocks configuration: %s" % self._dictstocks_config)
        # never used, by reload ? written but not used at this point
        return list_new

# ############ Function related to the server, define a client #########

## Used by C++ to activate / desactivate the client socket.
#
# tcp_client was created at the initialisation of DictionaryStocks.
# flag active true/false determine if guistock server is running.
# coded here easier for the integration with C++ 
def ActivateTCPClient():

    print "Activate TCPClient"
    # to check if necessary
    # better get the tcp_client from singleton dictionary
    global tcp_client
    
    #if ( tcp_client == None ):
    if ( tcp_client.GetActivity() == False ):    
        self.logger.info("activate tcp_client")
        #tcp_client = TCPClient()
        tcp_client.active = True
    else:
        self.logger.info("tcp_client already activated")

## Used by C++ to desactivate the client.    
def DesactivateTCPClient():

    print "Desactivate TCPClient"
    global tcp_client 
    
    #if ( tcp_client != None ):
    if ( tcp_client.GetActivity() == True ):
        #tcp_client = None
        tcp_client.active = False
        self.logger.info("desactivate tcp_client")
    else:
        self.logger.info("tcp_client already desactivated")


# seems impossible with the singleton, or some very tricky one ??
# the version created here under the __main__Dictionnar..., works as soon it is in a different file

# ############# Main only for standalone test ########

# # problem because DictStock variable in __name__, cannot access from import module !
# if __name__ == "__main__":