Skip to content
New: Star-import, signal unraveling, Python 3.12 support, and more

#
stx module

Module with STX.

## stx_config ReadonlyConfig

Factory config for STX.

## stx_func_config ReadonlyConfig

Exit function config for STX.

## STX class

    STX(
        wrapper,
        input_list,
        input_mapper,
        in_output_list,
        output_list,
        param_list,
        mapper_list,
        short_name,
        level_names
    )

Exit signal generator based on stop values.

Generates `exits` based on `entries` and stop_place_nb().

Hint

All parameters can be either a single value (per frame) or a NumPy array (per row, column, or element). To generate multiple combinations, pass them as lists.

Superclasses

- Analyzable
- AttrResolverMixin
- Cacheable
- Chainable
- Comparable
- Configured
- ExtPandasIndexer
- HasSettings
- IndexingBase
- IndicatorBase
- PandasIndexer
- Pickleable
- PlotsBuilderMixin
- Prettified
- StatsBuilderMixin
- Wrapping
- `vectorbtpro.signals.generators.stx.ParamIndexer`

Inherited members

- AttrResolverMixin.deep_getattr()
- AttrResolverMixin.post_resolve_attr()
- AttrResolverMixin.pre_resolve_attr()
- AttrResolverMixin.resolve_attr()
- AttrResolverMixin.resolve_shortcut_attr()
- Cacheable.get_ca_setup()
- Chainable.pipe()
- Configured.copy()
- Configured.equals()
- Configured.get_writeable_attrs()
- Configured.prettify()
- Configured.replace()
- Configured.resolve_merge_kwargs()
- Configured.update_config()
- HasSettings.get_path_setting()
- HasSettings.get_path_settings()
- HasSettings.get_setting()
- HasSettings.get_settings()
- HasSettings.has_path_setting()
- HasSettings.has_path_settings()
- HasSettings.has_setting()
- HasSettings.has_settings()
- HasSettings.reset_settings()
- HasSettings.resolve_setting()
- HasSettings.resolve_settings_paths()
- HasSettings.set_settings()
- IndexingBase.indexing_setter_func()
- IndicatorBase.cls_dir
- IndicatorBase.column_only_select
- IndicatorBase.column_stack()
- IndicatorBase.config
- IndicatorBase.dropna()
- IndicatorBase.group_select
- IndicatorBase.iloc
- IndicatorBase.in_output_names
- IndicatorBase.indexing_func()
- IndicatorBase.indexing_kwargs
- IndicatorBase.input_names
- IndicatorBase.lazy_output_names
- IndicatorBase.level_names
- IndicatorBase.loc
- IndicatorBase.output_flags
- IndicatorBase.output_names
- IndicatorBase.param_names
- IndicatorBase.plots_defaults
- IndicatorBase.range_only_select
- IndicatorBase.rec_state
- IndicatorBase.row_stack()
- IndicatorBase.run_pipeline()
- IndicatorBase.self_aliases
- IndicatorBase.short_name
- IndicatorBase.stats_defaults
- IndicatorBase.to_dict()
- IndicatorBase.to_frame()
- IndicatorBase.unpack()
- IndicatorBase.wrapper
- IndicatorBase.xloc
- PandasIndexer.xs()
- Pickleable.decode_config()
- Pickleable.decode_config_node()
- Pickleable.dumps()
- Pickleable.encode_config()
- Pickleable.encode_config_node()
- Pickleable.file_exists()
- Pickleable.getsize()
- Pickleable.load()
- Pickleable.loads()
- Pickleable.modify_state()
- Pickleable.resolve_file_path()
- Pickleable.save()
- PlotsBuilderMixin.build_subplots_doc()
- PlotsBuilderMixin.override_subplots_doc()
- PlotsBuilderMixin.plots()
- StatsBuilderMixin.build_metrics_doc()
- StatsBuilderMixin.override_metrics_doc()
- StatsBuilderMixin.stats()
- Wrapping.regroup()
- Wrapping.resample()
- Wrapping.resolve_column_stack_kwargs()
- Wrapping.resolve_row_stack_kwargs()
- Wrapping.resolve_self()
- Wrapping.resolve_stack_kwargs()
- Wrapping.select_col()
- Wrapping.select_col_from_obj()
- Wrapping.split()

Subclasses

- `vectorbtpro.signals.generators.stx._STX`

### apply_func method

    STX.apply_func(
        i,
        entries,
        entry_ts,
        ts,
        follow_ts,
        stop_ts,
        stop,
        trailing,
        exit_args,
        wait,
        until_next,
        skip_until_exit
    )

### custom_func method

    SignalFactory.with_place_func.<locals>.custom_func(
        input_list,
        in_output_list,
        param_list,
        *args,
        input_shape=None,
        place_args=None,
        entry_place_args=None,
        exit_place_args=None,
        entry_args=None,
        exit_args=None,
        cache_args=None,
        entry_kwargs=None,
        exit_kwargs=None,
        cache_kwargs=None,
        return_cache=False,
        use_cache=None,
        execute_kwargs=None,
        **_kwargs
    )

### entries property

Input array.

### entries_and method

    STX.entries_and(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries AND other`.

See combine_objs().

### entries_or method

    STX.entries_or(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries OR other`.

See combine_objs().

### entries_stats method

    STX.entries_stats(
        *args,
        **kwargs
    )

Stats of `entries` as signals.

### entries_xor method

    STX.entries_xor(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `entries XOR other`.

See combine_objs().

### entry_place_func_nb class variable

### entry_ts property

Input array.

### entry_ts_above method

    STX.entry_ts_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `entry_ts` is above `other`.

See combine_objs().

### entry_ts_below method

    STX.entry_ts_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `entry_ts` is below `other`.

See combine_objs().

### entry_ts_crossed_above method

    STX.entry_ts_crossed_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `entry_ts` is crossed_above `other`.

See combine_objs().

### entry_ts_crossed_below method

    STX.entry_ts_crossed_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `entry_ts` is crossed_below `other`.

See combine_objs().

### entry_ts_equal method

    STX.entry_ts_equal(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `entry_ts` is equal `other`.

See combine_objs().

### entry_ts_stats method

    STX.entry_ts_stats(
        *args,
        **kwargs
    )

Stats of `entry_ts` as generic.

### exit_place_func_nb method

    STX.exit_place_func_nb(
        c,
        entry_ts,
        ts,
        follow_ts,
        stop_ts_out,
        stop,
        trailing
    )

`place_func_nb` that places an exit signal whenever a threshold is being hit.

Note

Waiting time cannot be higher than 1.

If waiting time is 0, `entry_ts` should be the first value in the bar. If waiting time is 1, `entry_ts` should be the last value in the bar.

Args

`c` :`GenExContext` or `GenEnExContext`
  Signal context.
`entry_ts` :`array` of `float`

  Entry price.

  Utilizes flexible indexing.

`ts` :`array` of `float`

  Price to compare the stop value against.

  Utilizes flexible indexing. If NaN, defaults to `entry_ts`.

`follow_ts` :`array` of `float`

  Following price.

  Utilizes flexible indexing. If NaN, defaults to `ts`. Applied only if the stop is trailing.

`stop_ts_out` :`array` of `float`

  Array where hit price of each exit will be stored.

  Must be of the full shape.

`stop` :`array` of `float`

  Stop value.

  Utilizes flexible indexing. Set an element to `np.nan` to disable it.

`trailing` :`array` of `bool`

  Whether the stop is trailing.

  Utilizes flexible indexing. Set an element to False to disable it.

### exits property

Output array.

### exits_and method

    STX.exits_and(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `exits AND other`.

See combine_objs().

### exits_or method

    STX.exits_or(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `exits OR other`.

See combine_objs().

### exits_stats method

    STX.exits_stats(
        *args,
        **kwargs
    )

Stats of `exits` as signals.

### exits_xor method

    STX.exits_xor(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return `exits XOR other`.

See combine_objs().

### follow_ts property

Input array.

### follow_ts_above method

    STX.follow_ts_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `follow_ts` is above `other`.

See combine_objs().

### follow_ts_below method

    STX.follow_ts_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `follow_ts` is below `other`.

See combine_objs().

### follow_ts_crossed_above method

    STX.follow_ts_crossed_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `follow_ts` is crossed_above `other`.

See combine_objs().

### follow_ts_crossed_below method

    STX.follow_ts_crossed_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `follow_ts` is crossed_below `other`.

See combine_objs().

### follow_ts_equal method

    STX.follow_ts_equal(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `follow_ts` is equal `other`.

See combine_objs().

### follow_ts_stats method

    STX.follow_ts_stats(
        *args,
        **kwargs
    )

Stats of `follow_ts` as generic.

### plot method

    SignalFactory.__init__.<locals>.plot(
        _self,
        column=None,
        entry_y=None,
        exit_y=None,
        entry_types=None,
        exit_types=None,
        entry_trace_kwargs=None,
        exit_trace_kwargs=None,
        fig=None,
        **kwargs
    )

Plot STX.entries and STX.exits.

Args

`entry_y` :`array_like`
  Y-axis values to plot entry markers on.
`exit_y` :`array_like`
  Y-axis values to plot exit markers on.
`entry_types` :`array_like`
  Entry types in string format.
`exit_types` :`array_like`
  Exit types in string format.
`entry_trace_kwargs` :`dict`
  Keyword arguments passed to SignalsAccessor.plot_as_entries() for STX.entries.
`exit_trace_kwargs` :`dict`
  Keyword arguments passed to SignalsAccessor.plot_as_exits() for STX.exits.
`fig` :`Figure` or `FigureWidget`
  Figure to add traces to.
`**kwargs`
  Keyword arguments passed to SignalsAccessor.plot_as_markers().

### run class method

    STX.run(
        entries,
        entry_ts,
        stop,
        ts=nan,
        follow_ts=nan,
        trailing=Default(value=False),
        stop_ts=nan,
        short_name='stx',
        hide_params=None,
        hide_default=True,
        **kwargs
    )

Run STX indicator.

- Inputs: `entries`, `entry_ts`, `ts`, `follow_ts`
- In-place outputs: `stop_ts`
- Parameters: `stop`, `trailing`
- Outputs: `exits`

Pass a list of parameter names as `hide_params` to hide their column levels, or True to hide all. Set `hide_default` to False to show the column levels of the parameters with a default value.

Other keyword arguments are passed to IndicatorBase.run_pipeline().

### run_combs class method

    STX.run_combs(
        entries,
        entry_ts,
        stop,
        ts=nan,
        follow_ts=nan,
        trailing=Default(value=False),
        stop_ts=nan,
        r=2,
        param_product=False,
        comb_func=itertools.combinations,
        run_unique=True,
        short_names=None,
        hide_params=None,
        hide_default=True,
        **kwargs
    )

Create a combination of multiple STX indicators using function `comb_func`.

- Inputs: `entries`, `entry_ts`, `ts`, `follow_ts`
- In-place outputs: `stop_ts`
- Parameters: `stop`, `trailing`
- Outputs: `exits`

`comb_func` must accept an iterable of parameter tuples and `r`. Also accepts all combinatoric iterators from itertools such as `itertools.combinations`. Pass `r` to specify how many indicators to run. Pass `short_names` to specify the short name for each indicator. Set `run_unique` to True to first compute raw outputs for all parameters, and then use them to build each indicator (faster).

Other keyword arguments are passed to STX.run().

Note

This method should only be used when multiple indicators are needed. To test multiple parameters, pass them as lists to STX.run().

### stop_list property

List of `stop` values.

### stop_ts property

In-place output array.

### stop_ts_above method

    STX.stop_ts_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `stop_ts` is above `other`.

See combine_objs().

### stop_ts_below method

    STX.stop_ts_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `stop_ts` is below `other`.

See combine_objs().

### stop_ts_crossed_above method

    STX.stop_ts_crossed_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `stop_ts` is crossed_above `other`.

See combine_objs().

### stop_ts_crossed_below method

    STX.stop_ts_crossed_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `stop_ts` is crossed_below `other`.

See combine_objs().

### stop_ts_equal method

    STX.stop_ts_equal(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `stop_ts` is equal `other`.

See combine_objs().

### stop_ts_stats method

    STX.stop_ts_stats(
        *args,
        **kwargs
    )

Stats of `stop_ts` as generic.

### trailing_list property

List of `trailing` values.

### ts property

Input array.

### ts_above method

    STX.ts_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `ts` is above `other`.

See combine_objs().

### ts_below method

    STX.ts_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `ts` is below `other`.

See combine_objs().

### ts_crossed_above method

    STX.ts_crossed_above(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `ts` is crossed_above `other`.

See combine_objs().

### ts_crossed_below method

    STX.ts_crossed_below(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `ts` is crossed_below `other`.

See combine_objs().

### ts_equal method

    STX.ts_equal(
        other,
        level_name=None,
        allow_multiple=True,
        **kwargs
    )

Return True for each element where `ts` is equal `other`.

See combine_objs().

### ts_stats method

    STX.ts_stats(
        *args,
        **kwargs
    )

Stats of `ts` as generic.

#### Cookie consent

We use cookies to recognize your repeated visits and preferences, as well as to measure the effectiveness of our documentation and whether users find what they're searching for. With your consent, you're helping us to make our documentation better.

- Google Analytics
- GitHub

Manage settings