示例#1
0
    def init_selectors(self, entity_ids, entity_schema, exchanges, codes, start_timestamp, end_timestamp):
        ma_vol_selector = TargetSelector(entity_ids=entity_ids, entity_schema=entity_schema, exchanges=exchanges,
                                         codes=codes, start_timestamp=start_timestamp, end_timestamp=end_timestamp,
                                         provider='joinquant', level=IntervalLevel.LEVEL_1DAY)
        # 放量突破年线
        ma_vol_factor = ImprovedMaFactor(entity_ids=entity_ids, entity_schema=entity_schema, exchanges=exchanges,
                                         codes=codes, start_timestamp=start_timestamp - datetime.timedelta(365),
                                         end_timestamp=end_timestamp,
                                         provider='joinquant', level=IntervalLevel.LEVEL_1DAY)
        ma_vol_selector.add_filter_factor(ma_vol_factor)

        self.selectors.append(ma_vol_selector)
示例#2
0
    def init_selectors(self, entity_ids, entity_schema, exchanges, codes,
                       start_timestamp, end_timestamp):
        ma_vol_selector = TargetSelector(region=self.region,
                                         entity_ids=entity_ids,
                                         entity_schema=entity_schema,
                                         exchanges=exchanges,
                                         codes=codes,
                                         start_timestamp=start_timestamp,
                                         end_timestamp=end_timestamp,
                                         provider=Provider.JoinQuant,
                                         level=IntervalLevel.LEVEL_1DAY)
        # 放量突破年线
        ma_vol_factor = ImprovedMaFactor(region=self.region,
                                         entity_ids=entity_ids,
                                         entity_schema=entity_schema,
                                         exchanges=exchanges,
                                         codes=codes,
                                         start_timestamp=start_timestamp -
                                         datetime.timedelta(365),
                                         end_timestamp=end_timestamp,
                                         provider=Provider.JoinQuant,
                                         level=IntervalLevel.LEVEL_1DAY)
        # 底部附近突破
        cross_factor = CrossTopBottomFactor(region=self.region,
                                            entity_ids=entity_ids,
                                            entity_schema=entity_schema,
                                            exchanges=exchanges,
                                            codes=codes,
                                            start_timestamp=start_timestamp -
                                            datetime.timedelta(365),
                                            end_timestamp=end_timestamp,
                                            provider=Provider.JoinQuant,
                                            level=IntervalLevel.LEVEL_1DAY)
        ma_vol_selector.add_filter_factor(ma_vol_factor)
        ma_vol_selector.add_filter_factor(cross_factor)

        self.selectors.append(ma_vol_selector)
示例#3
0
def report_vol_up_120():
    while True:
        error_count = 0
        email_action = EmailInformer()

        try:
            # 抓取k线数据
            # StockTradeDay.record_data(provider='joinquant')
            # Stock1dKdata.record_data(provider='joinquant')

            latest_day: Stock1dKdata = Stock1dKdata.query_data(
                order=Stock1dKdata.timestamp.desc(),
                limit=1,
                return_type='domain')
            target_date = latest_day[0].timestamp

            # 计算均线
            my_selector = TargetSelector(start_timestamp='2019-06-01',
                                         end_timestamp=target_date)
            # add the factors
            factor1 = ImprovedMaFactor(start_timestamp='2019-06-01',
                                       end_timestamp=target_date,
                                       windows=[120])

            my_selector.add_filter_factor(factor1)

            my_selector.run()

            long_stocks = my_selector.get_open_long_targets(
                timestamp=target_date)

            msg = 'no targets'

            # 过滤亏损股
            # check StockValuation data
            pe_date = target_date - datetime.timedelta(10)
            if StockValuation.query_data(start_timestamp=pe_date,
                                         limit=1,
                                         return_type='domain'):
                positive_df = StockValuation.query_data(
                    provider='joinquant',
                    entity_ids=long_stocks,
                    start_timestamp=pe_date,
                    filters=[StockValuation.pe > 0],
                    columns=['entity_id'])
                bad_stocks = set(long_stocks) - set(
                    positive_df['entity_id'].tolist())
                if bad_stocks:
                    stocks = get_entities(provider='joinquant',
                                          entity_schema=Stock,
                                          entity_ids=bad_stocks,
                                          return_type='domain')
                    info = [f'{stock.name}({stock.code})' for stock in stocks]
                    msg = '亏损股:' + ' '.join(info) + '\n'

                long_stocks = set(positive_df['entity_id'].tolist())

            if long_stocks:
                stocks = get_entities(provider='joinquant',
                                      entity_schema=Stock,
                                      entity_ids=long_stocks,
                                      return_type='domain')
                # add them to eastmoney
                try:
                    try:
                        eastmoneypy.del_group('high')
                    except:
                        pass
                    eastmoneypy.create_group('high')
                    for stock in stocks:
                        eastmoneypy.add_to_group(stock.code, group_name='high')
                except Exception as e:
                    email_action.send_message(
                        "*****@*****.**", f'report_vol_up_120 error',
                        'report_vol_up_120 error:{}'.format(e))

                info = [f'{stock.name}({stock.code})' for stock in stocks]
                msg = msg + '盈利股:' + ' '.join(info) + '\n'

            logger.info(msg)

            email_action.send_message('*****@*****.**',
                                      f'{target_date} 改进版放量突破半年线选股结果', msg)

            break
        except Exception as e:
            logger.exception('report_vol_up_120 error:{}'.format(e))
            time.sleep(60 * 3)
            error_count = error_count + 1
            if error_count == 10:
                email_action.send_message(
                    "*****@*****.**", f'report_vol_up_120 error',
                    'report_vol_up_120 error:{}'.format(e))
示例#4
0
def report_state(region):
    while True:
        error_count = 0
        email_action = EmailInformer(ssl=True)

        try:
            latest_day: Stock1dKdata = Stock1dKdata.query_data(
                region=region,
                order=Stock1dKdata.timestamp.desc(),
                limit=1,
                return_type='domain')
            target_date = latest_day[0].timestamp
            # target_date = to_pd_timestamp('2020-01-02')

            # 计算均线
            my_selector = TargetSelector(region=region,
                                         start_timestamp='2018-01-01',
                                         end_timestamp=target_date)
            # add the factors
            factor1 = ImprovedMaFactor(region=region,
                                       start_timestamp='2018-01-01',
                                       end_timestamp=target_date)

            my_selector.add_filter_factor(factor1)

            my_selector.run()

            long_stocks = my_selector.get_open_long_targets(
                timestamp=target_date)
            stock_map_slope = {}

            logger.info(long_stocks)

            msg = 'no targets'

            if long_stocks:
                pre_date = target_date - datetime.timedelta(2 * 365)
                ma_state = MaStateStatsFactor(region=region,
                                              entity_ids=long_stocks,
                                              start_timestamp=pre_date,
                                              end_timestamp=target_date,
                                              need_persist=False)

                ma_state.factor_df['slope'] = 100 * ma_state.factor_df[
                    'current_pct'] / ma_state.factor_df['current_count']

                high_stocks = []
                for entity_id, df in ma_state.factor_df.groupby(level=0):
                    if df['current_pct'].max() >= 0.7:
                        high_stocks.append(entity_id)

                    stock_map_slope[entity_id] = round(df['slope'].iat[-1], 2)

                if high_stocks:
                    stocks = get_entities(region=region,
                                          provider=Provider.JoinQuant,
                                          entity_schema=Stock,
                                          entity_ids=high_stocks,
                                          return_type='domain')
                    info = [
                        f'{stock.name}({stock.code})[{stock_map_slope.get(stock.entity_id)}]'
                        for stock in stocks
                    ]
                    msg = msg + '2年内高潮过:' + ' '.join(info) + '\n'

            # 过滤风险股
            if long_stocks:
                risky_codes = risky_company(region=region,
                                            the_date=target_date,
                                            entity_ids=long_stocks,
                                            income_yoy=-0.8,
                                            profit_yoy=-0.8)

                if risky_codes:
                    long_stocks = [
                        entity_id for entity_id in long_stocks
                        if get_entity_code(entity_id) not in risky_codes
                    ]

                    stocks = get_entities(region=region,
                                          provider=Provider.JoinQuant,
                                          entity_schema=Stock,
                                          codes=risky_codes,
                                          return_type='domain')
                    info = [
                        f'{stock.name}({stock.code})[{stock_map_slope.get(stock.entity_id)}]'
                        for stock in stocks
                    ]
                    msg = msg + '风险股:' + ' '.join(info) + '\n'
            if long_stocks:
                stocks = get_entities(region=region,
                                      provider=Provider.JoinQuant,
                                      entity_schema=Stock,
                                      entity_ids=long_stocks,
                                      return_type='domain')
                # add them to eastmoney
                try:
                    try:
                        eastmoneypy.del_group('real')
                    except:
                        pass
                    eastmoneypy.create_group('real')
                    for stock in stocks:
                        eastmoneypy.add_to_group(stock.code, group_name='real')
                except Exception as e:
                    email_action.send_message(
                        "*****@*****.**", f'report state error',
                        'report state error:{}'.format(e))

                info = [
                    f'{stock.name}({stock.code})[{stock_map_slope.get(stock.entity_id)}]'
                    for stock in stocks
                ]
                msg = msg + '选中:' + ' '.join(info) + '\n'

            logger.info(msg)
            email_action.send_message('*****@*****.**',
                                      f'{target_date} 放量突破年线state选股结果', msg)
            break
        except Exception as e:
            logger.exception('report state error:{}'.format(e))
            time.sleep(60 * 3)
            error_count = error_count + 1
            if error_count == 10:
                email_action.send_message("*****@*****.**",
                                          f'report state error',
                                          'report state error:{}'.format(e))