def test_partial_data_in_dict(self):
        stock_data_file = GlobalVariables.get_data_files_path(
        ) + "stock_data_container_file.pickle"
        req_params = StrategyFactory.get_required_parameters_with_default_parameters(
        )

        missing_strategy_parameter_dict = {
            'W52HighTechnicalStrategy': {
                'check_days': 7,
                'min_cnt': 3,
                'min_vol_dev_fact': 1.2,
                'within52w_high_fact': 0.98,
                'data_readers': {
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': False,
                        'ticker_needed': True
                    }
                }
            }
        }

        other_params = {
            'stock_data_container_file': stock_data_file,
            'dict_with_stock_pages_to_read': {
                'SP500': {
                    'websource_address':
                    "http://en.wikipedia.org/wiki/List_of_S%26P_500_companies",
                    'find_name': 'table',
                    'class_name': 'class',
                    'table_class': 'wikitable sortable',
                    'ticker_column_to_read': 0,
                    'name_column_to_read': 1,
                    'stock_exchange': 'en'
                }
            },
            'RiskModels': {
                'FixedSizeRiskModel': {
                    'OrderTarget': 'order_target_value',
                    'TargetValue': 2500
                }
            }
        }

        all_strategy_parameters_dict = {
            'Strategies': missing_strategy_parameter_dict
        }
        all_strategy_parameters_dict.update({"OtherParameters": other_params})

        self.assertFalse(
            CommonUtils.have_dicts_same_shape(
                req_params['Strategies']['W52HighTechnicalStrategy'],
                missing_strategy_parameter_dict))
    def accept_parameters_from_text(self, params_dict, required_parameters):
        """
        Method to accept the changes in the scrolled text for the parameters,
         if the shape and keys of parameters dict is same as required parameters dict.
        :return: True, if parameters are valid and updated.
        """
        try:
            if isinstance(params_dict, dict):
                for param_key in params_dict.keys():
                    if not param_key in required_parameters.keys() or len(
                            params_dict[param_key]) <= 0:
                        logger.error(
                            "Parameter keys faulty, please insert correct parameters!"
                        )
                        return False

                    if not CommonUtils.have_dicts_same_shape(
                            required_parameters, params_dict):
                        logger.error(
                            "Parameter shapes are faulty, please insert correct parameters!"
                        )
                        return False

                self.model.analysis_parameters.clear()
                self.model.analysis_parameters.update(params_dict)
                self.model.available_strategies_list.clear()
                for item in params_dict['Strategies']:
                    self.model.available_strategies_list.append(item)
                logger.info("Analysis parameters Read")
            else:
                logger.error(
                    "Parameters are no dict, please insert correct parameters!"
                )
                return False

        except Exception as e:
            logger.error("Exception while opening result stock: " + str(e) +
                         "\n" + str(traceback.format_exc()))
            return False

        return True
    def test_data_in_dict(self):
        stock_data_file = GlobalVariables.get_data_files_path(
        ) + "stock_data_container_file.pickle"
        all_strategy_parameters_dict = {
            'SimplePatternNewsStrategy': {
                'news_threshold': 0.7,
                'german_tagger': GlobalVariables.get_data_files_path() +
                'nltk_german_classifier_data.pickle',
                'data_readers': {
                    'TraderfoxNewsDataReader': {
                        'last_check_date_file':
                        GlobalVariables.get_data_files_path() +
                        'TestData\\last_date_time.csv',
                        'german_tagger':
                        GlobalVariables.get_data_files_path() +
                        'nltk_german_classifier_data.pickle',
                        'reload_data':
                        True,
                        'ticker_needed':
                        False
                    },
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': True,
                        'ticker_needed': False
                    }
                }
            },
            'W52HighTechnicalStrategy': {
                'check_days': 7,
                'min_cnt': 3,
                'min_vol_dev_fact': 1.2,
                'within52w_high_fact': 0.98,
                'data_readers': {
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': False,
                        'ticker_needed': True
                    }
                }
            },
            'GapUpHighVolumeStrategy': {
                'min_gap_factor': 1.03
            }
        }
        other_params = {
            'stock_data_container_file': stock_data_file,
            'dict_with_stock_pages_to_read': {
                'SP500': {
                    'websource_address':
                    "http://en.wikipedia.org/wiki/List_of_S%26P_500_companies",
                    'find_name': 'table',
                    'class_name': 'class',
                    'table_class': 'wikitable sortable',
                    'ticker_column_to_read': 0,
                    'name_column_to_read': 1,
                    'stock_exchange': 'en'
                },
                'DAX': {
                    'websource_address':
                    "http://topforeignstocks.com/stock-lists/the-list-of-listed-companies-in-germany/",
                    'find_name': 'tbody',
                    'class_name': 'class',
                    'table_class': 'row-hover',
                    'ticker_column_to_read': 2,
                    'name_column_to_read': 1,
                    'stock_exchange': 'de'
                }
            },
            'RiskModels': {
                'FixedSizeRiskModel': {
                    'OrderTarget': 'order_target_value',
                    'TargetValue': 2500
                }
            },
            'AutoTrading': {
                'RepetitiveScreeningInterval': 120,
                'MaxNumberOfDifferentStocksToBuyPerAutoTrade': 5
            },
            'Broker': {
                'Name': 'IBPyInteractiveBrokers'
            }
        }

        backtesting_parameters = {
            'BacktestingFramework': 'BacktraderWrapper',
            'initial_cash': 30000,
            'trade_commission_percent': 0.005
        }

        all_strategy_parameters_dict = {
            'Strategies': all_strategy_parameters_dict
        }
        all_strategy_parameters_dict.update({"OtherParameters": other_params})
        all_strategy_parameters_dict.update(
            {"BacktestingParameters": backtesting_parameters})
        req_params = StrategyFactory.get_required_parameters_with_default_parameters(
        )

        self.assertTrue(
            CommonUtils.have_dicts_same_shape(req_params,
                                              all_strategy_parameters_dict))

        # key "news" instead of "news_threshold"
        corrupted_strategy_parameter_dict = {
            'SimplePatternNewsStrategy': {
                'news': 0.7,
                'german_tagger': GlobalVariables.get_data_files_path() +
                'nltk_german_classifier_data.pickle',
                'data_readers': {
                    'TraderfoxNewsDataReader': {
                        'last_check_date_file':
                        GlobalVariables.get_data_files_path() +
                        'TestData\\last_date_time.csv',
                        'german_tagger':
                        GlobalVariables.get_data_files_path() +
                        'nltk_german_classifier_data.pickle',
                        'reload_data':
                        True,
                        'ticker_needed':
                        False
                    },
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': True,
                        'ticker_needed': False
                    }
                }
            },
            'W52HighTechnicalStrategy': {
                'check_days': 7,
                'min_cnt': 3,
                'min_vol_dev_fact': 1.2,
                'within52w_high_fact': 0.98,
                'data_readers': {
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': False,
                        'ticker_needed': True
                    }
                }
            }
        }

        self.assertFalse(
            CommonUtils.have_dicts_same_shape(
                req_params, corrupted_strategy_parameter_dict))

        # missing 'SimplePatternNewsStrategy'
        missing_strategy_parameter_dict = {
            'W52HighTechnicalStrategy': {
                'check_days': 7,
                'min_cnt': 3,
                'min_vol_dev_fact': 1.2,
                'within52w_high_fact': 0.98,
                'data_readers': {
                    'HistoricalDataReader': {
                        'weeks_delta': 52,
                        'data_source': 'iex',
                        'reload_data': False,
                        'ticker_needed': True
                    }
                }
            }
        }

        self.assertFalse(
            CommonUtils.have_dicts_same_shape(req_params,
                                              missing_strategy_parameter_dict))