ValidStockUpdate.py

Go to the documentation of this file.

## @package serverportfolio.ValidStockUpdate
# @brief Define class ValidStockUpdate.
# 
# Last changed $Id$

# Split validation, check and save of a Stock after update

from __future__ import with_statement # 2.5 only

import logging, types, math
import datetime, time, threading

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

from serverportfolio.Validation import ValidationTkinter

## @class ValidStockUpdate
# @brief Extend class Stock with functions related to the validation and saving after a stock update: most of the post_process functionalities.
#
# Object is owned by a Stock object, created in Stock.post_process\n
#
# Internally dict_interactive is used to check and validate data from Stock.dict_stock\n
# In save_new_data it is merged back to Stock.dict_stock and write into file.
class ValidStockUpdate(object):
    ## @brief Constructor.
    # Always owned by a single parent Stock
    # @param parent_stock stock object
    # @param tk_manager instance of a ManagerTk, needed in interactive session
    def __init__(self, parent_stock, tk_manager=None):
        self._logger = logging.getLogger('SP.ValidUpdateStock')
        self._logger.debug('Init ValidUpdateStock')
        self._logger.debug('parent symbol: %s', parent_stock.symbol)
        self._logger.debug('tk_manager: %s' % tk_manager)
        ## @brief Associated to an unique stock.
        self._parent_stock = parent_stock
        ## @brief Dictionary of data after check_new_data.
        self._dict_interactive = {}
        ## @brief Store a ManagerTk interface in multi-thread mode.
        self._tk_manager = tk_manager

    ## @brief Return the parent Stock.
    def get_parent(self):
        return self._parent_stock

    ## @name Generic functions to valid a specific action
    ## @{

    ## @brief Assure the post_processing of a Stock after the parsing of one unique action.
    # This function is intended to be executed during the post_processing stage of a stock, with a specific action.
    # @param e_action action
    # @param option_post option to the post-process stage
    def post_process_one_action(self, e_action, option_post): #post_process in init ?
        self._logger.debug("post_process_one_action %s", e_action.name)
        interactive = option_post['interactive']
        to_save = option_post['to_save']
        # if to_save and interactive False. nothing to do !

        # reset dict_interactive for each new_action, maybe not if nothing to update ...
        # to be in init ? case multiple call ?
        # self._dict_interactive = {}
        # compare data and generate a valid dict_interactive
        try :
            self._logger.debug("== check new data")
            self.check_new_data( e_action, interactive)
        except PortfolioError as ex:
            self._logger.error("Caught PortfolioError in check_new_data")
            self._logger.error("ex: %s" % ex.get_format_string())
            raise
        # user validation if interactive
        if interactive == True:
            self._logger.debug("Interactive True")
            self._logger.debug("beforeGUI")
            try:
                self.valid_interactive() #e_action)
            except Exception as ex:
                self._logger.error("Caught Exception from ValidationTkinter ex: %s" % ex )
                raise
            self._logger.debug("out GUI dict_interactive: %s" % self._dict_interactive)
        # save to the filesystem
        if to_save:
            # better to test if empty, but should work and produce the same file, good for unit-test
            if any(self._dict_interactive):
                # merge dict_interactive to dict_xml, then write the file
                self.save_new_data(e_action)
            else:
                self._logger.info("dict_interactive is empty, nothing to update")
        else :
            self._logger.debug("Save flag not set")

    ## @brief Check the validity of the last updated values from Stock.dict_stock and generate dict_interactive.
    # Executed before an automatic or interactive update of the XML data (_dict_xml)\n
    # Updated data are stored in self.dict_interactive
    def check_new_data(self, e_action, interactive ):
        self._logger.debug("check_new_data e_action %s" % e_action)
        self._logger.debug("interactive %s", interactive)
        dict_inter_action = None
        # valid an xml update
        if self.get_parent().saved_as(e_action.name, 'xml'):
            try:
                # fill stock._dict_xml, to compare with previous values(if any)
                # Should check it is not already in memory !!
                # to move to read_xml ? better ?
                if not any(self.get_parent().get_dict_xml()):
                    self.get_parent().read_xml()
                # specific to one action
                dict_inter_action = self._valid_new_value_xml( e_action.name, interactive)
            except PortfolioError as ex:
                self._logger.error("Caught PortfolioError in check_new_data")
                raise
            except Exception as ex:
                self._logger.error("Caught Exception in check_new_data: %s" % ex)
                raise
        # case HistPrice/...
        if  self.get_parent().saved_as(e_action.name, 'csv'):
            try:
                # Only HistPrice is implemented, need other function ? or default one
                dict_inter_action = self._valid_new_value_csv( e_action.name, interactive )
            except PortfolioError as ex:
                self._logger.error("Caught PortfolioError in check_new_data")
                raise
            except Exception as ex:
                self._logger.error("Caught Exception in check_new_data: %s" % ex)
                raise

        # update dict_interactive
        if any(dict_inter_action):
            self._dict_interactive[e_action.name] = dict_inter_action

    ## @brief Final merge (after user/auto-validation) and write to file.
    # The correct format xml/csv is called.
    def save_new_data(self, e_action ):
        self._logger.debug("save_new_data e_action.name %s" % e_action.name)
        # save in xml format
        if self.get_parent().saved_as(e_action.name, 'xml'):
            try:
                self.save_new_xml_data()
            except Exception as ex:
                self._logger.info("Caught Exception ex:%s" % ex)
                raise
        # specific functions here
        if self.get_parent().saved_as(e_action.name, 'csv'):
            print "Deal with CSV"
            if e_action == EAction.HistPrice:
                if any(self._dict_interactive):
                    self.get_parent().save_hist_price()
            else:
                print "to write"

    ## @brief User validation of the new data.
    # Use a Tk GUI Interface for the validation.\n
    # Tkinter does not support multi-threading, a lock must be implemented.
    # Should try to regroup 2 interfaces in one
    def valid_interactive(self): # e_action not used
        self._logger.debug("valid_interactive, tk_manager %s" % self._tk_manager)
        try:
            # use tk_manager interface, necessary if not in the main thread
            if self._tk_manager:
                # update of dict_interactive, send to the queue and wait answer from the queue_answer
                self._tk_manager.write([self.get_parent().symbol, self._dict_interactive])
                self._dict_interactive = self._tk_manager.read_answer()
            # create directly the GUI
            else:
                app = ValidationTkinter(self.get_parent().symbol, self._dict_interactive)
                app.mainloop()
                # app use quit, not destroyed internally
                app.destroy()
        except Exception as ex:
            self._logger.error("Caught exception from ValidationTkinter/ ex:")
            raise
    ## @}  

# ############ Specific functions to deal with XML data
    ## @name Specific functions to deal with XML
    ## @{

#
# this function is not used,loop over action

    ## @brief Check the validity of the new retrieved data stored Stock._dict_stock.
    # Executed before an automatic or interactive update of the XML data (_dict_xml)\n
    # Valid data are stored in self.dict_interactive\n
    # @param opt_interactive optional validation by user (GUI)
    def check_new_xml_data(self, opt_interactive = False):
        self._logger.debug("opt_interactive %s", opt_interactive)
        dict_interactive = {}
        # create a list of data to update, need specialization by template ??
        # at best, check if some data are present !!
        self._logger.debug("_dict_stock: %s", self._dict_stock)
        # check global error ?
        #if self.get_dict_parser()['global_error']:
        #    self._logger.debug("Global Error ", self.get_dict_parser()['global_error'] )
        # loop over the recent action retrieved by parser
        for key,value in self.get_action().iteritems() :
            self._logger.debug("key/value %s %s" % (key, value))
               
            if self.saved_as( key, 'xml' ):
                # should not throw exception if possible, better error for interactive mode
                dict_action_inter = self._valid_new_value_xml( key, opt_interactive )
            
                if any(dict_action_inter):
                    dict_interactive[ key ] = dict_action_inter
             
            #else pass
    
        self._logger.debug("\nFinal dict_interactive:\n%s" % dict_interactive)
        print Utils.pretty_dict( dict_interactive )
        self.dict_interactive = dict_interactive

    ## @brief Final merge (after user/auto validation) and write XML file.
    # This step includes the merging of the data in self.dist_interactive,\n
    # and (re-)write the file by a call to write_xml, include TEST_MODE for unit-test
    def save_new_xml_data(self):
        self._logger.debug("Entry save_new_xml_data")
        # loop over the data in dict_interactive (have been validated)
        for (key_action, value_action) in self._dict_interactive.iteritems():
            self._logger.debug("key_action/value_action %s / %s" % (key_action, value_action))
            # dictionary to update
            dict_xml = self.get_parent().get_dict_xml( key_action )
            # for each action loop over key_data and value_data of dict_interactive 
            # check if modifed to 0 or 2
            for (key_data, value_data) in value_action.iteritems():
                self._logger.debug("\nkey_data / value_data %s / %s" % (key_data, value_data))
                # certainly to save, or to write into file for feedback
                if value_data['repl_add'] > 0:
                    self._logger.info("update xml value / key_data : %s / %s / %s " % \
                                     (self.get_parent().symbol, key_data, value_data['new_value']) )
                    # value can overwite the default, use the last one ...?
                    if dict_xml['template'][key_data][-1]['attrib']['append'] == True:
                        #b_append_data = True
                        print "append data"
                        new_tmpl_value = StTmpl.get_template_one_value_xml()
                        new_tmpl_value['value'] = value_data['new_value']
                        new_tmpl_value['attrib']['date'] = value_data['date']
                        new_tmpl_value['attrib']['source'] = value_data['source']
                        new_tmpl_value['attrib']['append'] = 'True'
                        # append to the list
                        dict_xml['template'][ key_data ].append( new_tmpl_value )
                    # replace the last value, do not modify the previous entries
                    else:
                        dict_xml['template'][ key_data ][-1]['value'] = value_data['new_value']
                        # format timestamp for C++, transform on the fly ? date added automatically
                        dict_xml['template'][ key_data ][-1]['attrib']['date'] = value_data['date']
                        dict_xml['template'][ key_data ][-1]['attrib']['source'] = value_data['source']
                # delete entry ? just pass   
                #else:
        self._logger.debug("dict_xml before wirte_xml:\n%s " % Utils.pretty_dict(self.get_parent().get_dict_xml()) )
        self._logger.debug("dict_xml before wirte_xml:\n%s " % (self.get_parent().get_dict_xml()) )
        try:
            self.get_parent().write_xml()
        except Exception as ex:
            self._logger.info("Caught Exception ex:%s" % ex)
            raise

# ####### Helper functions

    ## @brief Valid last values retrieved with parsers, try to guess values to be updated.
    # \pre last values in parent dict_stock and dict_stock should not be None, assert
    # @param key_action action name
    # @param interactive
    # @return value to be stored in dict_interactive['action']
    def _valid_new_value_xml(self, key_action, interactive ):
        self._logger.debug("Entry _valid_new_xml_value, key_action %s", key_action)
        self._logger.debug("interactive %s", interactive)
        # sure existing if here
        self._logger.debug("new_data / _dict_stock action %s", self.get_parent().get_action( key_action ))
        # not sure existing
        self._logger.debug("xml_data / _dict_xml %s", self.get_parent().get_dict_xml( key_action ))
        # shortcut action / key for new_data and xml_data
        new_data = self.get_parent().get_action( key_action )
        assert ( new_data != None ), "New_data should not be None at this stage"
        # always try to update the source, better when initialising a new XML file
        # assert to test at start of post-process
        assert 'source' in new_data, "source is missing"
        new_data_source = new_data['source']

        # maybe empty, maybe better to init in get_dict_xml, certainly
        # could ask xml_dict_value / xml_dict_config
        xml_data = self.get_parent().get_dict_xml( key_action )

        # look like a global attrib entry was present (from _templ_action), and then specific for each value
        #if xml_data['config']['attrib']['source'] == None:
        #    xml_data['config']['attrib']['source'] = new_data_source

        # values to update, all will be finally stored dict_interactive
        dict_inter_action = {}
        # named data, e.g. 'BVPS' : value
        # cannot delete entry during an iteration with iteritems(), with keys() seems ok
        # loop over new_data, could be used with only one or 2 entries ?
        for key_data in new_data.keys():
            # case of other...only if interactive
            if (key_data == 'other') | (key_data == 'error') | (key_data == 'source'): # source exception catched and continue
                continue
            # shortcut and allow to correct type in case of None (in XML)
            new_value = new_data[key_data]
            # get the last one from the list
            # try maybe could be used with 'other', here only for test
            try :
                xml_value = xml_data['template'][key_data][-1]['value']
            # empty template one_value not correct 
            except:
                self._logger.error("key_data %s not found in xml_value" % key_data)
                # to set a default ? '',0 ?
                continue
            # type_value is dependent of action
            if ( key_action == "Fundamental"):
                type_values =  types.FloatType
            elif ( key_action == 'Info'):
                type_values = types.StringType
            else:
                self._logger.error("action not implemented in list_update_xml_value_generic")
                type_values = types.StringType
            # should work for most for these two types. send only simple variable, no lists
            try:
                status = ValidStockUpdate.check_value( new_value, xml_value, type_values )
            # happens in case of None and None, return 2 wrong
            except Exception as ex:
                self._logger.info("Exception check_value: new_value %s, xml_value %s, status %d" % (new_value, xml_value, status))
                self._logger.info("ex: %s" % ex)

            self._logger.debug("new_value %s, xml_value %s, status %d" % (new_value, xml_value, status))

            # discard data by default, delete from _dict_parser, do not insert in the dict_interactive
            # xml unchanged
            if ( status <= 0 ) | ( ( status==1) & (not interactive) ):
                self._logger.debug("Discard this data")
                # Can delete during iteration with keys() or values() only
                # del self.get_dict_parser( key_action )[key_data]
                continue
            # interactive session, status == 2 force update
            # insert element of comparison in dict_interactive    
            elif (status == 2 ) | (( status == 1) & interactive) :
                # get a deepcopy, erase previous data
                # validXML should not be in templ
                #tmpl_new_value = StTmpl.get_template_stock("ValidXML")
                tmpl_new_value = StTmpl.get_template_valid_xml_value()
                # fill with new value
                tmpl_new_value['new_value'] = new_value
                # original value
                tmpl_new_value['xml_value'] = xml_value
                # date could come from parser, today is also ok
                tmpl_new_value['date'] = datetime.datetime.now().strftime("%Y-%m-%d")
                # status for the mode of update
                tmpl_new_value['repl_add'] = status
                # update source, needed here, to pass to final dictionary
                tmpl_new_value['source'] = new_data_source
                # add all terms to dict_interactive
                dict_inter_action[ key_data ] = tmpl_new_value
        self._logger.debug("dict_inter_action %s: %s" % (key_action,dict_inter_action))
        return dict_inter_action

    ## @}

    ## @name Specific functions to deal with CSV data
    ## @{
 
# not used, loop over all actions   
    ## @brief Check the CSV data are not wrong.
    #
    # Bug with Yahoo, sometimes data download are wrong (can be similar in the web page).
    # Bug found:
    #   - Volume all 0, or some 0
    #   - All values are identical : 4703.3, 4703.3, 4703.3, 4703.3
    #   - GSZ : 25 and 26 December, 1 january same value, volume 0 ! (can be hard coded a for a few days..)
    #
    # Return True if correct, and then can proceed with saving the data into file.\n
    # Return False, some errors are found, the data should not be saved by default. But still downloadable ?
    #
    # Set global error to HistPrice, set local HistPrice error
    # return True if correct
    # to extend DivSplit, InstValue not needed now
    def check_list_csv(self, opt_interactive = False):
        self._logger.debug("check_list_csv interactive %s", opt_interactive)
        
        dict_interactive = {}
        
    # only list_csv or list_split, list_div to update
        # loop over the recent action retrieved by parser, common to HistPrice... 
        for key_action,value in self.get_action().iteritems() :
        
            # apply only to HistPrice
            if key_action != 'HistPrice':
                continue
            
            dict_action_inter = self._valid_new_value_csv( key_action, opt_interactive )
            
            # return false if only key is integer(0), should not happen if here (and HistPrice/list_csv)
            #if any(dict_action_inter):
            if len(dict_action_inter):
                dict_interactive[ key_action ] = dict_action_inter
        
        self._logger.debug("\nFinal dict_interactive:\n%s" % dict_interactive)
        
        # because of key integer, cannot use
        #print Utils.pretty_dict( dict_interactive )
        self.dict_interactive = dict_interactive
        
        # with GSZ HistPrice, example of output without error, to use in test
        # new_data / _dict_parser {'source': 'YCSV', 'last_date': datetime.datetime(2015, 3, 2, 0, 0), 
        # 'first_date': datetime.datetime(1970, 1, 1, 1, 0), 
        # 'list_csv': [[1425250800, 19.8, 19.86, 19.37, 19.44, 6279800.0], [1424991600, 19.46, 19.88, 19.35, 19.88, 8207000.0], [1424905200, 19.51, 19.74, 19.39, 19.48, 6426300.0], [1424818800, 19.25, 19.45, 19.17, 19.29, 5575500.0], [1424732400, 18.86, 19.35, 18.62, 19.24, 8116600.0], [1424646000, 18.8, 18.84, 18.59, 18.81, 5173700.0], [1424386800, 18.66, 18.74, 18.44, 18.59, 6623200.0], [1424300400, 18.53, 18.69, 18.43, 18.68, 5664000.0], [1424214000, 18.91, 18.98, 18.56, 18.68, 4637300.0], [1424127600, 18.51, 18.76, 18.27, 18.74, 4519600.0], [1424041200, 18.71, 18.72, 18.54, 18.6, 3649000.0], [1423782000, 18.89, 18.92, 18.72, 18.72, 6893900.0], [1423695600, 18.75, 18.86, 18.5, 18.8, 5891100.0], [1423609200, 18.99, 19.0, 18.67, 18.77, 5178200.0], [1423522800, 18.75, 18.99, 18.5, 18.96, 4967600.0], [1423436400, 18.9, 18.94, 18.53, 18.68, 6571700.0], [1423177200, 19.19, 19.21, 19.0, 19.01, 4635800.0], [1423090800, 19.33, 19.4, 19.1, 19.15, 8390900.0], [1423004400, 19.63, 19.73, 19.46, 19.6, 5781600.0], [1422918000, 19.9, 20.05, 19.55, 19.7, 9223500.0], [1422831600, 19.72, 19.88, 19.59, 19.83, 4641200.0]], 
        #  'error': None}
       
# Only HistPrice checked     
    ## @brief Fill dict_interactive in case of list of data (HistPrice action implemented)
    # dict_inter_action stores chronological group of data, with or without errors. Same notation status 0, 1 or 2.\n
    # Groups are continguous data considered as valid or invalid.
    # @param key_action name of the action
    # @param interactive boolean if interactive mode is present. Wrong data will have a status of 1 if active.
    # @return a dict_interactive for this specific action
    def _valid_new_value_csv(self, key_action, interactive):
        self._logger.debug("action %s", key_action)
        # copy code from _check_new_xml
        self._logger.debug("Entry _valid_new_value_csv: %s", self.get_parent().symbol)
        self._logger.debug("interactive %s", interactive)
        # sure existing if here
        self._logger.debug("new_data / _dict_parser %s", self.get_parent().get_action( key_action ))
        # shortcut param action / key
        new_data = self.get_parent().get_action( key_action )
        assert ( new_data != None ), "New_data should not be None at this stage"
        # values to update, all stored finally in dict_interactive
        dict_inter_action = {}
        # use as key for dict_interactive
        count_group = 0
        for key_data in new_data.keys():
            # check dates, only for list, maybe 'list_*'
            # only stored in dict_inter_action[HistPrice], what for Div/Split ?
            if key_data != 'list_csv':
                continue

            #initial value, first for sure exists ?
            first_date = Utils.timestamp_to_string(new_data[key_data][0][0])
            first_values = new_data[key_data][0]
            # need a function here status, error = _error_list_csv(values) 
            first_status, first_error = ValidStockUpdate._error_list_csv(new_data[key_data][0], interactive)
            # case only one value !
            count_values = 0
            #print "number of data", (len(new_data[key_data]))
            #for values in self.get_dict_parser(key_action)['list_csv']:
            for values in new_data[key_data][1:]:  #['list_csv'] only list_csv ?
            # can check first and last dates correspond to dates saved in templates
                count_values += 1
                # check specific for HistPrice with YahooCSV, list of possible bugs
                status, error = ValidStockUpdate._error_list_csv(values, interactive)
                if (status != first_status) | ( count_values == ( len(new_data[key_data])-1) ) :
                    #dict_inter_action[key_data][count_group] = {
                    dict_inter_action[count_group] = {
                                        'repl_add' : first_status,
                                        'error' : first_error,
                                        'first_date': first_date,
                                        'first_values' : first_values,
                                        # need previous one if not at the end
                                        'last_date': Utils.timestamp_to_string( new_data[key_data][count_values-1][0] ),
                                        'last_values' : new_data[key_data][count_values-1]
                                        }
                    # if last data in list, overwrite last and break
                    if count_values == len(new_data[key_data]) :
                        dict_inter_action[count_group]['last_date'] = Utils.timestamp_to_string(values[0])
                        dict_inter_action[count_group]['last_values'] = values
                        break
                    # still some data
                    count_group += 1
                    # reset first to actual
                    first_status = status
                    first_error = error
                    first_date = Utils.timestamp_to_string( values[0] )
                    first_values = values
        self._logger.debug("dict_inter_action %s: %s" % (key_action,dict_inter_action))
        return dict_inter_action

    ## @brief Check for common error in historical price data and return a status and an error code.
    # @param values all 6 values [date,4 values,volume] in list_csv (HistPrice)
    # @param interactive boolean
    # @return tuple(status,error_code)
    @staticmethod
    def _error_list_csv( values, interactive ):
        # default error
        status = 0
        # can change interactively all entries
        if interactive:
            status = 1
        # default value
        error = ''
        # check values bug, second overwrittes
        if values[1] == values[2] == values[3] == values[4]:
            error = 'values equal'
        if float(values[5]) == 0:
            error = 'volume missing'
        else:
            status = 2
        return (status, error)

# to write, using a very similar wrapper. data already in stock
# previous in YahooCSV.UpdateCSV 
#             GetListCSV replaced by UpdateStocks.update_data
# here only to test ? or done before ?
#           to send new_data to wrapPyStock.UpdateCSV( self.symbol, listCSV, GlobalDicts.TEST_MODE )
# function to write : py_to_C, (C_to_py) , generic function to transform structure list_csv and other.

# Not used here ? only in Stock ? still in use ?
    ## @brief Generate a sub-list of list_csv, starting from the last call until the last_date (included)
    # 
    # First call, after initialization, start at the first data of the list\n
    # Not found a nice way to run the first call, must use None\n
    # or could pass the list_data as well, but confusing...
    # @code
    # self.gen_part_of_list_csv(None)
    # sub_list_generator.send(None)
    # ...
    # sub_list = sub_list_generator.send( last_date )
    # @endcode
    #
    # @param last_date, certainly always the
    # @return a list of csv [last_call, last_date] 
    def gen_part_of_list_csv(self, last_date):
        #self._logger.debug("entry gen_part_list_csv, last_date %s %s" % (last_date,Utils.timestamp_to_string(last_date)))
        self._logger.debug("entry gen_part_list_csv, last_date %s " % (last_date) )
        assert 'list_csv' in self.get_action('HistPrice'),'list_csv not loaded !'
        # only for initialization send(None)
        if last_date == None:
            last_date = yield None
        # fixed to this list, not chronologic in memory
        p_list = self.get_action('HistPrice','list_csv')
        i = len(p_list)-1

        part_list = []
        while i >= 0:
            if p_list[i][0] <= last_date:
                part_list.append(p_list[i])
            else:
                # return the sub-list
                last_date = yield part_list
                # last_date updated and reinitialise a new sub-list
                part_list = [ p_list[i] ]
            i -= 1
        # what's for the last ? never called.
        return
    ## @}

    # ########## Static methods

    ## @brief Generic function to check if new_value can be updated.
    # Return:
    # - 2 Update in all cases
    # - 1 Propose to update if Interactive, otherwise discard. Output in log to control(maybe other file). Used also if new_value is the default one.
    # - 0 Invalid, eliminate in all cases
    # -1 Valid but identical, no point to update
    #
    # A conversion of new_value and xml_value to type_value are performed as a check\n
    # No exception are throw if types are wrong and return 0
    # @param new_value recent value, obtained from parsers
    # @param xml_value last value in xml
    # @param type_value StringType or FloatType. Integers are converted to float.
    @staticmethod
    def check_value(new_value, xml_value, type_value):
        #print "new_value ", new_value
        #print "xml_value ", xml_value
        #print "type to convert ", type_value
        # try to convert, and check value if convertible
        try:
            # throw ValueError, float('a'), eliminate all alplanumeric, case of 56B, to deal in Parser
            new_value = type_value(new_value)
            status = ValidStockUpdate.is_valid_value( new_value, type_value )
        # float(None) return TypeError, do not care really, rejected at this point
        except (ValueError,TypeError): # as ex:
            # static method
            #self._logger.info("Error in type_value or is_valid_value")
            return 0
        except Exception as ex:
            #self._logger.info("Got exception ex: %s", ex)
            print "Got exception ex: %s", ex
            return 0
        # status 0 is not valid
        if status == 0:
            return 0
        # test previous xml value
        # if no modif, empty XML gives a NoneType
        # need to check this
        if xml_value == None:
            #print "new_value ", new_value
            xml_value = type_value()
            # for sure nothing interessant here, can happen ??
            if (new_value == None) | (new_value == type_value()):
                print "\n ValidStockUpdate, case xml_value is None and new_value is also the default\n"
                return 0
            # nothing to loose    
            return 2
        # normal case, a valid string, at worst a '0' string, can make more try type_value() is correct
        try:
            xml_value = type_value(xml_value)
        except Exception as ex:
            # mark as error, should be None or castable
            #self._logger.error("Got Exception in conversion of xml_value ex: %s" % ex)
            return 1
        # same value no update to do
        if new_value == xml_value:
            return -1
        # new added, maybe more general 
        if new_value == type_value():
            print "\n ValidStockUpdate, case new_value is default\n"
            return 0
        # certainly a bad new value, works only for float, no string
        #if (new_value <= 0) & ( xml_value > 0 ):
        #    return 1
        # else a good new_value
        return 2

    ## @brief Guess if the input value is valid.
    # A conversion to the type is tested efore in the code...
    # Used only to test new value, the xml_value is considered already valid\n
    # Return 0, 1 or 2:
    # - 0 not valid: float('nan')
    # - 1 valid
    # - -1 type_value is not implemented
    # @note A conversion to the type_value is tested before, not explicitely in the function.\n But if type_value is Float and the value not convertible, a TypeError s thrown 
    # @param value input
    # @param type_value type of the value: string or float. Other will return -2
    @staticmethod
    def is_valid_value(value, type_value):
        if type_value == types.FloatType:
            if math.isnan( value ):
                return 0
            # else valid
            return 1
        # else string..., should not be '' 
        elif type_value == types.StringType:
            if value == '':
                return 0
            # accept all other string
            return 1
        # not a valid entry, to print in log
        else:
            return -1