UpdateStocks.py

Go to the documentation of this file.

## @package serverportfolio.UpdateStocks
# @brief Define class UpdateStocks and ParserFactory.
#
# Regroup main functions to update stocks (call parsers to query web page and post-processing: save_to_file/save_to_xml/interactive mode)\n
# Module made apart from DictionaryStocks and Stock to avoid circular/recursive import\n
#
# Last Changed $Id: UpdateStocks.py 29 2015-05-05 11:09:54Z michael $

# Object and associated parser can be re-used if they use identical parser (YahooCSV can do many actions on historic data)
# To develop methods to change parser if required

import types, logging
import threading

from serverportfolio.DictionaryStocks import DictionaryStocks
# Stock not needed ? always work with symbol, of through DictionaryStocks
# can use obj_stock.state, imported indirectly by DictionaryStock ?
# from serverportfolio.Stock import Stock, InvalidStock


from serverportfolio import Utils
from serverportfolio.GlobalDicts import EAction
from serverportfolio.PortfolioException import PortfolioError, ParserError, QueryError

from serverportfolio.Parsers.Parser_Bourso import Parser_Bourso
from serverportfolio.Parsers.YahooCSV import YahooCSV
from serverportfolio.Parsers.YahooYQL import YahooYQL

# only for new added static methods
from serverportfolio.Validation import ManagerTk

## @class UpdateStocks
# @brief Update data of a list of Stock's (only one action by call is possible).
#
# This module allows to choose:
# - multi-thread mode : if possible with the action
# - option for the post-processing: save to file, interactive session
#
# Create and store a appropriate parser object to query a web page and make the post-processing: validation/interactive mode, save_to_file/save_to_xml.\n
# Re-use of the internal parser object needed only for Server, to improve.\n
#
# Used mainly by the RunParser tool.\n
# Used by C++, with simple arguments.\n
# If optional argument easy to implement in C++, can be provided in constructor.
class UpdateStocks(object):

    ## @brief Constructor.
    # @param action EAction or string of the action to perform, 'NoAction' will not initialise the internal parser.
    # @param option_parser (not implemented)
    # @param option_multithread if possible for the action, parsers are run in independent threads
    def __init__(self, action, option_parser = None, opt_multithread = False): #, load_all_stocks=False): 
        #option to add: load_all_stocks, (to_send_gui_server, case ServerPortfolio), (to_C++,only if C++ call or gui_serfer), 
        # ( to_write_XML == to_save_file == to_save/to_update, depends on the action )
        # 
        # to_interactive important, X choices: 
        #    1.  the caller ask for data to validate, with generator maybe...(caller python/C++), caller knows what to query (caller wait or thread needed)
        #    2.  UpdateStocks proposes validation form(s) (simple console, simple gui in python) when it is ready and blocks there (simplest), can avoid thread.
        #    3.       //      send a validation form to the caller (need some wrapper/interface to store caller python/C++) need thread/process for sure
        #                                                           use gui_server ? maybe easier...
        #
        # multi_threads (number of threads ?) inside or by caller ? easier to split between thread here
                        
        self._logger = logging.getLogger('SP.UpdateStocks')
        self._logger.debug('Init UpdateStocks')
        self._logger.debug('action: %s', action)
         
        # function stringToEAction, can throw a PortfolioError
        self.e_action = Utils.stringToEAction( action )
        
        # maybe option, one fixed parser or not is a good idea ?
        # e_action NoAction implemented
        try:
            self._myparser = ParserFactory.create_parser( self.e_action, option_parser )
        # raise a parser error
        except ParserError as ex:
            print "Catch ParserError form ParserFactory ex.get_format_string()"
            #raise PortfolioError( "Error in ParserFactory", ex.get_format_string())
            raise
        
        ## @brief Link to the DictionaryStocks singleton.
        # Could pass the option load_all_stocks if created from here...
        self._dictstocks = DictionaryStocks()
        ## @brief Allow multi-threading for executing _update_data. 
        # @todo check if works for InstValue, HistPrice (DivSplit also).
        self._multithread = opt_multithread
        ## @brief Indicates if the new data must be saved into the file system, post-processing stage.
        # Apply to all types : 'csv' and 'xml'\n
        # Default is True, for debugging/testing may need to set to False
        self.b_save = True
        ## @brief Set interactive mode, the user is required to accept / reject the update of data.
        self.b_interactive = False
        
    ## @brief To set/unset the options b_save and b_interactive. 
    # @param bool_save boolean to set/unset the option to save to file.
    # @param bool_interactive to set/unset the interative mode
    def set_option_post(self, bool_save = True, bool_interactive = False):
        self.b_save = bool_save
        self.b_interactive = bool_interactive

    ## @brief Return a new dictionary with the option for post-processing.
    # An entry 'tk_manager' will be added only if needed (interactive/multithread) and supported by action
    # @return dictionary with keys: 'to_save', 'interactive' and 'tk_manager' 
    def get_option_post(self):
        tmp = {'to_save' : self.b_save,
               'interactive' : self.b_interactive,
               'tk_manager' : None
              }
        return tmp
    
# to make clear, not a bad idea
    ## @brief Set or reset an action, a correct parser depending on the action.
    # Try to re-use the same parser object if the same action is required.\n
    # If not possible, create a new one\n
    # Called from _update_data\n
    # @param action_name string or EAction to execute  
    def _set_parser(self, action_name):
        self._logger.debug("_set_parser")
        status = ParserFactory().is_compatible( self._myparser, action_name)
        self._logger.debug("status %s", status)
        
        # throw a PortfolioError
        self.e_action = Utils.stringToEAction( action_name )

        if status == False:
            self._myparser = ParserFactory.create_parser( self.e_action )
        
    ## @name Wrapper to DictionaryStocks functionalities
    ## @{
    
    ## @brief Return a Stock (or a list of Stock) object(s) from a symbol (or a list of symbols).
    # May return InvalidStocks, wrapper to DictionaryStocks.get_stocks()
    def get_stocks(self, stock):
        return self._dictstocks.get_stocks(stock)
    
    ## @brief Print one line strings of the data.
    # @todo Check arguments all used ? all needed ?
    def print_dict_stocks(self, action, input_stocks = None, opt_all_stocks = False, opt_header = False ):
        return self._dictstocks.print_dict_stocks( action, input_stocks, opt_all_stocks, opt_header)
    ## @}
    
# ############### update functions

    ## @brief Update stock(s) data according to the specified action.
    # If a specific stock or list of stocks symbol is provided, the Stock object may be created on the fly\n
    # If the default None is used, only the Stock objects already loaded in the dictionary are used(option update_all may be added)\n
    #   
    # The function provides access to any action.
    # if option save is set (by default) data are saved in their respective file. 
    # If multithread is required with action InstValue or HistPrice, a thread is created for each thread in this function.
    #
    # Other post-processes (print, send data to gui_server) must be done by the caller\n
    #
    # @param stock symbol (or list of symbols) of the stock, default None update all stocks from the loaded Stocks (not all from config)
    # @param action string of the action, must be valid as defined in GlobalDicts.EAction. If None use the default specified in constructor. 
    #        All cases check the parser is compatible with the action.
    # @param opt_parser option to use a specific parser(not implemented, use only the default one)
    def _update_data( self, stock, action = None): #, opt_parser = None ):
        self._logger.debug("_update_data stocks: %s" % (stock) )
        self._logger.debug("action to perform: %s" % action )
        self._logger.debug("self.e_action to perform: %s" % self.e_action )

        list_stock=[]
        # messy this option... can call : list_stock = self.get_stock_keys(), implements keyword for stock ALL
        # if stock is None:
            # default all_stock = False (need option in update_data? easier to call DictStocks load all in caller?)
            # option True working, Stock not created there. Not sure so useful...
        #    list_stock = self.get_stock_keys() # all_stocks=True )
        # if one string is given, a list with one element is returned, otherwise return the initial list
        # else :
        list_stock = Utils.to_list( stock )

# complex option NoAction ? only use previous parser or change
        # if None use the default
        if (action == None) & (self.e_action != EAction.NoAction):
            pass
        # load a new parser if needed, re-use existing if compatible
        elif action != None:
            self._set_parser( action )

        assert(self._myparser != None),"Error in _update_data, the parser could not be created"
        assert(self.e_action != EAction.NoAction),"Error in _update_data, the parser could not be created"
        
        # new added pass option to run_parser, to finalise post-processing of the stocks
        option_post = self.get_option_post()

# maybe easier to have run_thread(list_stock, action) # always stock by stock by default, but concurrent
#                       run_singlethread(list_stock, action)  #always a list of stock in entry, default for multiple stocks query. option mt= True/False to force and test
# multi-thread could be called 2 times for update of Info, made specific run_parser_info in YQL.

        # Theses actions support only 1 stock, this info could be stored with the action.
        # we can reuse the parser or implement multi-threading
        if (self.e_action == EAction.InstValue) | (self.e_action == EAction.HistPrice) | \
           (self.e_action == EAction.DivSplit) | (self.e_action == EAction.DatesIntro):

            # create multiple threads, each deal with one Stock only
            if self._multithread:

    # run_multithread
    # if many stocks/ can limit the number of threads ?
    # if many actions... much more complex, need a pool of threads to reuse ! to forget for now !
    # maybe make a simpler version, a derived class may implement more options ?
                self._logger.debug("multithread activated")
                
                # interactive and mutlithread, need the TkManager
                #if self.b_interactive:
                #    option_post['tk_manager'] = TkManager()
                
                # if mutlithtread and interactive
                if self.b_interactive:
                    option_post['tk_manager'] = ManagerTk()
                     
                # create a first thread, responsible of the pool of threaded parsers
                t = threading.Thread(target=run_thread_pool_parser, args=(list_stock, self.e_action, option_post)).start()
                
                # main thread waits data from parsers
                if self.b_interactive:
                     option_post['tk_manager'].update_me()
                # need to wait in a way
                else:
                    t.join()
                
                   
                
    # like run_thread to do a static function
    # main thread may 
#                 thread_list = []
#                 # alternative
#                 # threads = [threading.Thread(target=loop, args=(f, repeats)) 
#                 #            for i in range(nthreads)]
#                 
#                 for stock in list_stock:
#                     # run_thread makes pre and post processing for the single stock methods
#                     t = threading.Thread(target=self.run_thread, name="thread_"+stock, args = (stock,self.e_action))
#                     thread_list.append(t)
# 
#                 for th in thread_list:
#                     th.start()
# 
#                 # master waits all thread to end
#                 for th in thread_list:
#                     th.join()

                self._logger.debug("mutlithread done")

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

            # all done in one thread, loop over the list
            # could call the same static function run_thread_parser(stock, e_action, option_post), if clear with set_parser use
            else :
    # run_singlethread() parse/ post-process included
                self._logger.debug("single thread, make a loop")
                       
                for stock in list_stock :

                    try :
                        self._myparser.run_parser( stock, option_post )
                        # specific error
                    except ParserError as ex:
                        self._logger.error("_update_data caught a ParserError from run_parser: %s" % ex)
                        # should raise a PortfolioError or still continue ?
                        raise
                    # parsing may generate many errors, catch all
                    except Exception as ex:
                        self._logger.error("_update_data caught an Exception from run_parser : %s" % ex)
                        print "error message ",ex
                        raise
                        # maybe better to change to a ParserError or PortfolioError

                    # single_thread, post_process now or after ?  
                    #self.post_process(stock, self.e_action)
                    
                #self.post_process( list_stock, self.e_action)
                    
    # #################
        # these actions with default parser support multiple stocks, no need to loop over stock
        # can force mutlithread to retrieve all Fundamental, can extend _multithread to this case, divide with nb_thread
        # AllAction ? split the job in different threads (how to join after?)
        elif (self.e_action == EAction.Info) | (self.e_action == EAction.Fundamental):
            
        # run_single_thread
            # not yet pre/post processing case here, can add later
            #self.pre_process()
            
            # case Info need 2 parsing. If only use of YQL could override run_parser
            # run_parser_info has been implemented in YQL, may derive an other class
            try:
                # in this case makes 2 parsings with YahooYQL
                # specific case or to make derive class YQL_Info only rewrite run_parser ?
                if (self.e_action == EAction.Info) & (isinstance( self._myparser, YahooYQL)):
                    self._myparser.run_parser_info( list_stock, option_post )
                # normal, all other cases
                else:
                    self._myparser.run_parser( list_stock, option_post )
                    
            # specific error, PortfolioError ?? to catch simpler !
            # for test, maybe better
            except ParserError as ex:
                self._logger.error("_update_data caught a ParserError from run_parser: %s" % ex)
                # should raise a PortfolioError or still continue ? can change to PortfolioError, which advantage ?
                raise
            
            except QueryError as ex:
                self._logger.error("_update_data caught a QueryError from run_parser: %s" % ex)
                raise
            # parsing may generate many errors, catch all
            except Exception as ex:
                self._logger.error("_update_data caught an Exception from run_parser : %s" % ex)
                raise
            
            # same for post-processing
            #self.post_process(list_stock, self.e_action)

             
# ################## split pre / run / post-process
    
# moved into Stock, saved_as( e_action, 'csv' ) more general or just HistPrice ?
# to delete
    # Only HistPrice at the moment, do stock by stock in multi or single thread
#     def pre_process(self, stock, e_action):
#         print "pre_process"
#         
#         if ( self.e_action == EAction.HistPrice ):
#             # bad way, many loop. Better to call pre_process( one_stock )/run/post-process
#             self.get_stocks( stock ).last_CSV( e_action.name )
            
    # Only HistPrice and Instvalue at the moment, deal only with one stock
    # All action needed, update_xml slightly more general. PostProcess class, with implementation 'action dependent' avoid if
    # problem with Validation, need two steps: check_new_data / create dict_interactive
    #                                          if interactive: call user validation
    #                                          apply validation
    #
    # difficult to have multi-thread and interactive
# start to move post-process to Stock, called by run_parser(), need to pass some options, need to deal with multi-thread
#     def post_process(self, list_stock,e_action):
#         self._logger.debug("UpdateStocks post_process")
#         self._logger.debug("stock/e_action: %s/%s" % (list_stock,e_action.name))
#         
#         list_stock = Utils.to_list(list_stock)
#         
#         opt_post = { 
#             'interactive': self.b_interactive,
#             'to_save' : self.b_save
#         }
#         
#         for stock in list_stock:
#             self._logger.debug("stock: %s" % stock)
#             self.get_stocks( stock ).post_process( e_action, opt_post )        
#                 
# maybe should not be in the class ? not needed in fact
# only one stock in this function



# ################# End processing
        
# could have an option, opt_force, make a new parsing or not, easier for all modules using DictStocks in Server/RunParser
# option GET, opt_parse called only if Server is working 

# only for tests, to delete
# ##### function of test, update_xml is restrictive, and interactive force to split the function
    ## @brief
    def update_xml(self, stock):
        self._logger.debug("Entry update_xml stock %s" % stock)
        
        if not self.save_xml:
            self._logger.debug("update_xml, but save_xml is False, return")
            return
        self._logger.debug("mode interactive %s" % self.b_interactive)
        
        list_stock = Utils.to_list( stock )
        # need to read the file
        for stock_symb in list_stock:
            
            obj_stock = self.get_stocks(stock_symb)
            obj_stock.read_xml() 
        
            try :
                obj_stock.check_new_data(self.b_interactive)
            except PortfolioError as ex:
                self._logger.error("Caught PortfolioError")
                raise
        
            if self.b_interactive == False:
                
                # better to test if empty, but should work and produce the same file, good for unit-test
                # ok pass with FP test, input == output
                if any(obj_stock._dict_interactive):
                    obj_stock.save_new_data_to_xml()
                else:
                    self._logger.debug("dict_interactive is empty, nothing to update")
            
            else:
                print "Interactive to write"
                
 # ##### End test function       
        
        
    ## @brief Update the stock(s) and return the data as multi lines string.
    #
    # Should work for all actions, print one line by stock.\n
    # Easy to call and parse from C++ or other scripts. Called by default by RunParsers.
    #
    # @param list_stock of the stock symbols
    # @param action
    # @param opt_header optional boolean, print a header before the data
    # @param opt_parse if True call an update of the data, if False only print values in memory     
    def get_string_data( self, list_stock, action=None, opt_header=False, opt_parse=True ):
        self._logger.debug("Entry get_string_data %s opt_parse: %s" % (self.e_action, opt_parse))
        
        if opt_parse:
            # make the update of the new data, for use with option GET not needed
            self._update_data(list_stock, action)
        
        # post-process, create a multi-line string
        lines = self.print_dict_stocks( self.e_action.name, list_stock, opt_header = opt_header )
        return lines
        
    ## @brief Parse instantaneous value and check the stock is in state 'OPEN'.
    # Called only at the start of AutoParser.\n
    # or may call _update_data from AutoParser, and then check with Stock get_state
    #
    # @pre Parser must be loaded with InstValue action (done in AutoParser)
    #
    # @param stock one unique stock symbol
    # @return boolean if state is 'OPEN'
    def check_open(self, stock ):
        self._logger.debug("Entry check_open")
        # assert InstValue for the parser
        self._update_data( stock )
        #print "state ", DictionaryStocks().get_stocks( stock ).state
        if self.get_stocks( stock ).state == 'OPEN':
            return True
        # else
        return False

## @name Static functions dealing with thread creation, execution
## @{
    
## @brief Create and run a pool of thread parsers.
# In interactive session, assure the creation of a TkManager and its deletion.
# @param stock list of stock symbol
# @param e_action EAction to perform
# @param option_post option for the post_processing
def run_thread_pool_parser(list_stock, e_action, option_post): #run_thread_parser as argument possible, nice for unit-test
    print "Entry thd_pool_run name", threading.current_thread().name
    
    #pydevd.settrace( 5678 )
    # default
    ref_tk_manger = None
    
    # if interactive session
    if option_post['interactive'] == True:
        ref_tk_manager = option_post['tk_manager']
        assert ref_tk_manager is not None, "Error in option post"
        
    thread_list = []
    for stock in list_stock:
        t = threading.Thread(target=run_thread_parser, name="thread_"+stock, args = (stock, e_action, option_post))
        thread_list.append(t)

    for th in thread_list: th.start()
    # master waits all thread to end
    for th in thread_list: th.join()
        
    if ref_tk_manager:
        print "thd_pool all joined, send quit signal"
        ref_tk_manager.write(["QUIT"])
    print "thread_pool will die..."

## @brief Create and run the parsing of one action for an unique stock.
# Parsing includes pre and post-processing: validation and saving the data to file.
# @param stock symbol
# @param e_action EAction to perform
# @param option_post post-processing option
def run_thread_parser(stock, e_action, option_post):
    logger = logging.getLogger('SP.UpdateStocks.thread_parser')
    logger.debug("run_thread name %s" % threading.current_thread().name)
    logger.debug("stock %s", stock)
    logger.debug("e_action %s", e_action.name)
    logger.debug("option_post %s" % option_post)
    
    # costly, need to create a parser for each thread
    try :
        parser = ParserFactory.create_parser( e_action ) #option_parser )
    except:
        print "Got an exception "
        raise
    
    # case of Info/YQL ? run_parser_info ? No Info use only one thread
    try :
        parser.run_parser( stock, option_post )
    # specific error
    except ParserError as ex:
        logger.error("run_thread_parser caught a ParserError from run_parser: %s" % ex)
        # should raise a PortfolioError or still continue ?
        raise
    # parsing may generate many errors, catch all
    except Exception as ex:
        logger.error("run_thread_parser caught an Exception from run_parser: %s" % ex)
        raise
    # moved to Stock, run by run_parser
    # how to deal with interactive if multithread ? need queue/other thread to serialize
    #self.post_process(stock, e_action)
    
    ## @}
    
## @class ParserFactory
# @brief Helper functions, all the functions to create a specific parser from a given action.
# Used only by UpdateStocks
class ParserFactory:

    ## @brief Possible action to perform and the associated parsers.
    _ACTION = {
            EAction.Info:['YQL'], # 'YHTML'
            EAction.HistPrice:['YCSV'],
            EAction.DatesIntro:['YCSV'], # use an HTML page, keep in same module YahooCSV, later maybe YHTML
            EAction.DivSplit:['YCSV'], #['YQL'], #or YCSV with_x(seems better
            EAction.InstValue:['BOURSO'], # Only boursorama, to extend to YHTML
            EAction.Fundamental:['YCSV','YQL'] # YHTML or YCSV also
            }
    
    # for is_compatible(), need Abstract.type() and inverse dictionary (can be checked on the fly)
    # YCSV : ['HistPrice','DatesIntro','Fundamental']
    # YQL  : ['Info'], Fundamental
    # BOURSO : ['InstValue'

    _logger = None
        
    ## @brief Return a specific parser, according to the action.
    # Action determine the parser to use, the first one in the entry by default
    # @param e_action EAction to perform
    # @param option optional parser. By default the first in the list is chosen (not implemented)
    @classmethod
    def create_parser( cls, e_action, option = {} ):
        
        cls._logger = logging.getLogger( 'SP.ParserFactory' )
        cls._logger.debug("CreateParser e_action: %s, option: %s" % (e_action.name, option) )
        
        if e_action == EAction.NoAction:
            return None
        # use only default option
        try:
            default_option = cls._ACTION[ e_action ]
            cls._logger.debug("default_option %s " % default_option)
        except:
            cls._logger.critical("Error action %s not in list ACTION or is invalid" % (e_action.name) )
            raise ParserError( "Cannot create a Parser from the action %s" % e_action.name, \
                               None, e_action.name, None )
        # check option, check if action compatible with this option
        # if option and not compatible, warning ?
        opt_parser = default_option[0]

        # if default in Action, should test over Action
        # switch case would be nice
        # http://bytebaker.com/2008/11/03/switch-case-statement-in-python/
        # Boursorama supports only InstValue, only one stock
        if opt_parser == 'BOURSO': 
            assert ( e_action == EAction.InstValue ),"Error in combination Boursorama / %s" % ( e_action )
            parser = Parser_Bourso( e_action )
            
        # for HistPrice, now can have price + dividence with g=v (but not split)
        # for Fundamental/Info can use explicit list with old api
        elif opt_parser == 'YCSV':
            # test all actions, for each check option_yahoo or default
            # html/'YQL'/x : html default for getting HP
            parser = YahooCSV( e_action )

        elif opt_parser == 'YQL':
            parser = YahooYQL( e_action )
        
        else:
            # should never reach here assert
            cls.logger.debug("option parser not yet implemented %s" % opt_parser)
            raise ParserError( "option parser not yet implemented %s" % opt_parser, \
                               'None', e_action.name, 'None' )

        return parser

# parser.source implemented, solve partly the problem ?
#
# tricky does not know the exact parser used(in case of option, only the previous action), now parser.source is implemented !
# to be sure, need to know the exact Parser. Can be in Abstract.type () avoid to test isinstance, ovelroaded by parser
# but tricky in the list does not mean we want to use the optional parser...
# need to know YQL : [list of actions]
    # actual_action was not enough
    @classmethod
    def is_compatible(cls, actual_parser, new_action_name):
        cls._logger.debug('is_compatible')
        cls._logger.debug('test current parser.source: %s', actual_parser.source)
        print "is_compatible"
        print "actual_parser.source ", actual_parser.source
        
        # if it does not exist, or NoAction ?
        #if actual_parser.e_action.name == 'NoAction':
        if actual_parser == None:
            return False
        
        # second quick test
        if actual_parser.e_action.name == new_action_name:
            #cls.logger.debug("Same action, return True")
            print "Same action, return True"
            return True
        
        print "return False"
        return False

        # Utils.stringToEAction
        try :
            #if type(action) == types.StringType:
            new_action = EAction[new_action_name]
            #else: #isisntance(EAction) to check
            #    self.e_action = action
        except :
            #cls._logger.critical("Error action %s not in list ACTION or is invalid" % (new_action_name) )
            raise ParserError( "Cannot create a Parser from the action %s" % new_action_name, \
                               None, new_action_name, None )
            
        # to do later, maybe not so important
        # actual_action
        # actual_possible_action = cls._ACTION
        
# for testing/debugging purpose
# Implements all actions:
# - Only one stock InstValue, HistPrice, DivSplit, DatesIntro
# - Multiple stocks: Fundamental, Info
if __name__ == "__main__":

    import sys,traceback
    import GlobalDicts

    logging.basicConfig(level=logging.DEBUG) #WARNING)
    logging.getLogger('SP')
    m_logger = logging.getLogger("SP.main")
    # To use entry in ROOT_application/data_test (unit_test)
    #GlobalDicts.PATH_DICT=GlobalDicts.PATH_DICT_TEST
    try:
        m_stock = sys.argv[1]
        m_action = sys.argv[2]
        # output: 'string','pretty_dict','XML' ?
        # option interactive/threads/to_save similar to RunParsers
    except IndexError:
        print " Only for debugging, should call ./Run_Parsers for all options "
        print " Usage:"
        print " UpdateStocks CAC40,FSLR InstValue"
        print " Action: all actions, thread option"
        sys.exit(1)
    m_logger.debug("Entry Main UpdateStocks")
    #print "\n== Create a NoAction UpdateStocks"
    #m_no_action = UpdateStocks('NoAction')
    #print "action ", m_no_action.e_action.name
    m_update_stocks = None
    # transform to a list, from format "Stock1,Stock2,.."
    m_list_stock = m_stock.split(',')
    m_logger.debug("list_stock: %s", m_list_stock)
    print "\n== Create UpdateStocks"
    # assign an action (can be 'NoAction')
    try:
        m_update_stocks = UpdateStocks( m_action, opt_multithread=True)
    except PortfolioError as ex:
        print "Caught PortfolioError from UpdateStocks()"
        print ex.get_format_string()
        sys.exit(1)
    except Exception as ex:
        print "Caught Exception ex:",ex
        sys.exit(1)
    print "action ", m_update_stocks.e_action.name
    #sys.exit(1)
# #############
    # basic function, run the parser(threads), but no post-processing, not really... maybe...
    # could be private
    #m_update_stocks._update_data( action, list_stock ) #load the list of stock
    #m_update_stocks._update_data( action ) #default None, but nothing loaded in DictStocks
    # need some sort of manual post-processing
    # only print the dictionary as final processing
    #for stock in list_stock:
    #    print Utils.pretty_dict( DictionaryStocks().get_stocks( stock ).get_dict_data() )
# ############ get string format

# now action is fixed, with the parser. 
# To test more to change parser on the fly

    #                               b_save, b_interactive
    m_update_stocks.set_option_post( True, True )
    try:
        m_lines = m_update_stocks.get_string_data( m_list_stock, m_action, opt_header=True)
        #m_lines = no_action.get_string_data( m_list_stock, m_action, opt_header=True)
    except PortfolioError as ex:
        print "Catch PortfolioError, ex: %s" % ex
        print ex.get_format_string()
        sys.exit(1)
    except Exception as ex:
        print "Catch Exception ex: %s" % ex
        print "traceback:\n", traceback.format_exc(3)
        sys.exit(1)
    m_logger.debug("\n==result")
    print m_lines
# ########## Test interactive console for HistPrice
#     try:
#         # can make the update from python if no error ??
#         status = update_stocks._update_data( action, list_stock )
# 
#     except PortfolioError as ex:
#         print "Catch PortfolioError, ex: %s" % ex
#         print ex.get_format_string()
#         sys.exit(1)
#         
#     except Exception as ex:
#         print "Catch Exception ex: %s" % ex
#         sys.exit(1)
#     
#     print  "\n==result "
#     print  "status ", status
#     
#     print "\n get the errors"
#     error_lines = DictionaryStocks().get_stocks( list_stock ).get_error()
#     
#     if error_lines is None:
#         print "No Error, can update all the data"
#         
#     else: 
#         print "Found error, can update some ?? if volume missing can deal with it and check later ??"
#         for error in error_lines:
#             print error
#         
#     print "\n get the list_csv"
#     lines_csv = DictionaryStocks().get_stocks( list_stock ).get_dict_data('HistPrice')['list_csv']
#     for csv in lines_csv:
#         print csv
#         
#     print (30 * '-')
#     print ("   M A I N - M E N U")
#     print (30 * '-')
#     print ("1. Save")
#     print ("2. Discard")
#     #print ("3. Reboot the server")
#     print (30 * '-')
#     
#     is_valid=0
#     while not is_valid :
#         
#         try :
#                 choice = int ( raw_input('Enter your choice [1-2] : ') )
#                 if (choice < 1) | (choice > 2 ):
#                     raise ValueError( 'an error : ' + str(choice) )
#                 # pass
#                 is_valid = 1 # set it to 1 to validate input and to terminate the while..not loop
#                 
#         except ValueError, e :
#                 print "e ", e
#                 print ("'%s' is not a valid integer." % e.args[0].split(": ")[1])
#  
#     # Take action as per selected menu-option ###
#     if choice == 1:
#         print ("Save the data...")
#         #DictionaryStocks().get_stocks( list_stock[0] ).save_hist_price()
#     elif choice == 2:
#         print ("Discard the data...")
#         pass
#     #elif choice == 3:
#     #    print ("Rebooting the server...")
#     else:
#         print ("Invalid number. Try again...")