예제 #1
0
    def init_selectors(self,
                       entity_ids,
                       entity_schema,
                       exchanges,
                       codes,
                       start_timestamp,
                       end_timestamp,
                       adjust_type=None):
        myselector = TargetSelector(
            entity_ids=entity_ids,
            entity_schema=entity_schema,
            exchanges=exchanges,
            codes=codes,
            start_timestamp=start_timestamp,
            end_timestamp=end_timestamp,
            provider="em",
        )

        myselector.add_factor(
            DragonTigerFactor(
                entity_ids=entity_ids,
                exchanges=exchanges,
                codes=codes,
                start_timestamp=start_timestamp,
                end_timestamp=end_timestamp,
            ))

        self.selectors.append(myselector)
예제 #2
0
    def init_selectors(self,
                       entity_ids,
                       entity_schema,
                       exchanges,
                       codes,
                       start_timestamp,
                       end_timestamp,
                       adjust_type=None):
        # 日线策略
        start_timestamp = next_date(start_timestamp, -50)
        day_selector = TargetSelector(
            entity_ids=entity_ids,
            entity_schema=entity_schema,
            exchanges=exchanges,
            codes=codes,
            start_timestamp=start_timestamp,
            end_timestamp=end_timestamp,
            long_threshold=0.7,
            level=IntervalLevel.LEVEL_1DAY,
            provider="joinquant",
        )
        day_gold_cross_factor = GoldCrossFactor(
            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,
        )
        day_selector.add_factor(day_gold_cross_factor)

        self.selectors.append(day_selector)
예제 #3
0
    def init_selectors(self,
                       entity_ids,
                       entity_schema,
                       exchanges,
                       codes,
                       start_timestamp,
                       end_timestamp,
                       adjust_type=None):
        start_timestamp = next_date(start_timestamp, -50)

        # 周线策略
        week_selector = TargetSelector(entity_ids=entity_ids,
                                       entity_schema=entity_schema,
                                       exchanges=exchanges,
                                       codes=codes,
                                       start_timestamp=next_date(
                                           start_timestamp, -200),
                                       end_timestamp=end_timestamp,
                                       long_threshold=0.7,
                                       level=IntervalLevel.LEVEL_1WEEK,
                                       provider='joinquant')
        week_bull_factor = BullFactor(entity_ids=entity_ids,
                                      entity_schema=entity_schema,
                                      exchanges=exchanges,
                                      codes=codes,
                                      start_timestamp=next_date(
                                          start_timestamp, -200),
                                      end_timestamp=end_timestamp,
                                      provider='joinquant',
                                      level=IntervalLevel.LEVEL_1WEEK)
        week_selector.add_factor(week_bull_factor)

        # 日线策略
        day_selector = TargetSelector(entity_ids=entity_ids,
                                      entity_schema=entity_schema,
                                      exchanges=exchanges,
                                      codes=codes,
                                      start_timestamp=start_timestamp,
                                      end_timestamp=end_timestamp,
                                      long_threshold=0.7,
                                      level=IntervalLevel.LEVEL_1DAY,
                                      provider='joinquant')
        day_gold_cross_factor = GoldCrossFactor(
            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)
        day_selector.add_factor(day_gold_cross_factor)

        # 同时使用日线,周线级别
        self.selectors.append(day_selector)
        self.selectors.append(week_selector)
예제 #4
0
def report_targets(
    factor_cls: Type[Factor],
    entity_provider,
    data_provider,
    title,
    entity_type="stock",
    informer: EmailInformer = None,
    em_group=None,
    em_group_over_write=True,
    filter_by_volume=True,
    adjust_type=None,
    start_timestamp="2019-01-01",
    **factor_kv,
):
    logger.info(
        f"entity_provider: {entity_provider}, data_provider: {data_provider}, entity_type: {entity_type}, start_timestamp: {start_timestamp}"
    )
    error_count = 0

    while error_count <= 10:
        try:
            if not adjust_type:
                adjust_type = default_adjust_type(entity_type=entity_type)

            target_date = get_latest_kdata_date(provider=data_provider,
                                                entity_type=entity_type,
                                                adjust_type=adjust_type)
            logger.info(f"target_date :{target_date}")

            current_entity_pool = None
            if filter_by_volume:
                # 成交量
                vol_df = get_top_volume_entities(
                    entity_type=entity_type,
                    start_timestamp=next_date(target_date, -30),
                    end_timestamp=target_date,
                    adjust_type=adjust_type,
                    pct=0.4,
                    data_provider=data_provider,
                )
                current_entity_pool = vol_df.index.tolist()
                logger.info(
                    f"current_entity_pool({len(current_entity_pool)}): {current_entity_pool}"
                )

            kdata_schema = get_kdata_schema(entity_type,
                                            level=IntervalLevel.LEVEL_1DAY,
                                            adjust_type=adjust_type)
            filters = []
            if "turnover_threshold" in factor_kv:
                filters = filters + [
                    kdata_schema.turnover >=
                    factor_kv.get("turnover_threshold")
                ]
            if "turnover_rate_threshold" in factor_kv:
                filters = filters + [
                    kdata_schema.turnover_rate >=
                    factor_kv.get("turnover_rate_threshold")
                ]
            if filters:
                filters = filters + [kdata_schema.timestamp == target_date]
                kdata_df = kdata_schema.query_data(
                    provider=data_provider,
                    filters=filters,
                    columns=["entity_id", "timestamp"],
                    index="entity_id")
                if current_entity_pool:
                    current_entity_pool = set(current_entity_pool) & set(
                        kdata_df.index.tolist())
                else:
                    current_entity_pool = kdata_df.index.tolist()

            if "entity_ids" in factor_kv:
                if current_entity_pool:
                    current_entity_pool = set(current_entity_pool) & set(
                        factor_kv.pop("entity_ids"))
                else:
                    current_entity_pool = set(factor_kv.pop("entity_ids"))

            # add the factor
            my_selector = TargetSelector(start_timestamp=start_timestamp,
                                         end_timestamp=target_date,
                                         select_mode=SelectMode.condition_or)
            entity_schema = get_entity_schema(entity_type=entity_type)
            tech_factor = factor_cls(
                entity_schema=entity_schema,
                entity_provider=entity_provider,
                provider=data_provider,
                entity_ids=current_entity_pool,
                start_timestamp=start_timestamp,
                end_timestamp=target_date,
                adjust_type=adjust_type,
                **factor_kv,
            )
            my_selector.add_factor(tech_factor)

            my_selector.run()

            long_stocks = my_selector.get_open_long_targets(
                timestamp=target_date)

            inform(
                informer,
                entity_ids=long_stocks,
                target_date=target_date,
                title=title,
                entity_provider=entity_provider,
                entity_type=entity_type,
                em_group=em_group,
                em_group_over_write=em_group_over_write,
            )

            break
        except Exception as e:
            logger.exception("report error:{}".format(e))
            time.sleep(60 * 3)
            error_count = error_count + 1
            if error_count == 10:
                informer.send_message(
                    zvt_config["email_username"],
                    f"report {entity_type}{factor_cls.__name__} error",
                    f"report {entity_type}{factor_cls.__name__} error: {e}",
                )
예제 #5
0
파일: report_utils.py 프로젝트: zvtvz/zvt
def report_targets(
    factor_cls: Type[Factor],
    entity_provider,
    data_provider,
    title,
    entity_type="stock",
    em_group=None,
    em_group_over_write=True,
    filter_by_volume=True,
    adjust_type=None,
    start_timestamp="2019-01-01",
    **factor_kv,
):
    logger.info(
        f"entity_provider: {entity_provider}, data_provider: {data_provider}, entity_type: {entity_type}, start_timestamp: {start_timestamp}"
    )
    error_count = 0

    while error_count <= 10:
        email_action = EmailInformer()

        try:
            if entity_type == "stock" and not adjust_type:
                adjust_type = AdjustType.hfq

            target_date = get_latest_kdata_date(provider=data_provider,
                                                entity_type=entity_type,
                                                adjust_type=adjust_type)
            logger.info(f"target_date :{target_date}")

            current_entity_pool = None
            if filter_by_volume:
                # 成交量
                vol_df = get_top_volume_entities(
                    entity_type=entity_type,
                    start_timestamp=next_date(target_date, -30),
                    end_timestamp=target_date,
                    adjust_type=adjust_type,
                    pct=0.4,
                )
                current_entity_pool = vol_df.index.tolist()
                logger.info(
                    f"current_entity_pool({len(current_entity_pool)}): {current_entity_pool}"
                )

            # add the factor
            my_selector = TargetSelector(start_timestamp=start_timestamp,
                                         end_timestamp=target_date,
                                         select_mode=SelectMode.condition_or)
            entity_schema = get_entity_schema(entity_type=entity_type)
            tech_factor = factor_cls(
                entity_schema=entity_schema,
                entity_provider=entity_provider,
                provider=data_provider,
                entity_ids=current_entity_pool,
                start_timestamp=start_timestamp,
                end_timestamp=target_date,
                adjust_type=adjust_type,
                **factor_kv,
            )
            my_selector.add_factor(tech_factor)

            my_selector.run()

            long_stocks = my_selector.get_open_long_targets(
                timestamp=target_date)

            msg = "no targets"

            if long_stocks:
                entities = get_entities(provider=entity_provider,
                                        entity_type=entity_type,
                                        entity_ids=long_stocks,
                                        return_type="domain")
                if em_group:
                    try:
                        codes = [entity.code for entity in entities]
                        add_to_eastmoney(codes=codes,
                                         entity_type=entity_type,
                                         group=em_group,
                                         over_write=em_group_over_write)
                    except Exception as e:
                        email_action.send_message(
                            zvt_config["email_username"],
                            f"report {entity_type}{factor_cls.__name__} error",
                            f"report {entity_type}{factor_cls.__name__} error: {e}",
                        )

                infos = [
                    f"{entity.name}({entity.code})" for entity in entities
                ]
                msg = "\n".join(infos) + "\n"

            logger.info(msg)

            email_action.send_message(zvt_config["email_username"],
                                      f"{target_date} {title}", msg)

            break
        except Exception as e:
            logger.exception("report error:{}".format(e))
            time.sleep(60 * 3)
            error_count = error_count + 1
            if error_count == 10:
                email_action.send_message(
                    zvt_config["email_username"],
                    f"report {entity_type}{factor_cls.__name__} error",
                    f"report {entity_type}{factor_cls.__name__} error: {e}",
                )