Frozen public API¶

The following 81 functions are the frozen public-function counterparts of gp3sequences 0.3.0.

`as_arules_sequences()`¶

gp3sequencespy.as_arules_sequences ¶

as_arules_sequences(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
) -> ArulesSequenceAdapter

`as_grpstring_data()`¶

gp3sequencespy.as_grpstring_data ¶

as_grpstring_data(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    alphabet: Sequence[str] | None = None,
) -> GrpStringInput

`as_igraph_transition_network()`¶

gp3sequencespy.as_igraph_transition_network ¶

as_igraph_transition_network(
    network: DataFrame, directed: bool = True
) -> nx.Graph

`as_seqhmm_sequences()`¶

gp3sequencespy.as_seqhmm_sequences ¶

as_seqhmm_sequences(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    **kwargs: Any,
) -> WideSequenceAdapter

`as_traminer_sequences()`¶

gp3sequencespy.as_traminer_sequences ¶

as_traminer_sequences(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    missing: Any = None,
    right: str = "DEL",
    **_: Any,
) -> WideSequenceAdapter

`audit_sequence_analysis()`¶

gp3sequencespy.audit_sequence_analysis ¶

audit_sequence_analysis(
    x: Any, strict: bool = False, tolerance: float = 1e-08
) -> SequenceAnalysisAudit

`audit_sequence_data()`¶

gp3sequencespy.audit_sequence_data ¶

audit_sequence_data(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
) -> pd.DataFrame

Audit long-format sequence data without modifying it.

`bootstrap_sequence_clusters()`¶

gp3sequencespy.bootstrap_sequence_clusters ¶

bootstrap_sequence_clusters(
    distance: Any,
    k: int,
    method: str = "hierarchical",
    n_boot: int = 100,
    sample_fraction: float = 0.8,
    seed: int = 1,
    linkage: str = "average",
    **kwargs: Any,
) -> SequenceClusterBootstrap

`bootstrap_sequence_group_difference()`¶

gp3sequencespy.bootstrap_sequence_group_difference ¶

bootstrap_sequence_group_difference(
    inference: SequenceGroupInference,
    n_boot: int = 999,
    level: float = 0.95,
    seed: int = 1,
) -> SequenceGroupInference

`bootstrap_transition_network()`¶

gp3sequencespy.bootstrap_transition_network ¶

bootstrap_transition_network(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    n_boot: int = 100,
    level: float = 0.95,
    seed: int = 1,
    include_self: bool = True,
) -> pd.DataFrame

`cluster_sequences()`¶

gp3sequencespy.cluster_sequences ¶

cluster_sequences(
    distance: Any,
    k: int,
    method: str = "hierarchical",
    linkage: str = "average",
    seed: int = 1,
    **kwargs: Any,
) -> SequenceClustering

`compare_sequence_analysis_results()`¶

gp3sequencespy.compare_sequence_analysis_results ¶

compare_sequence_analysis_results(
    x: Any,
    y: Any,
    tolerance: float = 1e-08,
    compare_values: bool = False,
) -> SequenceAnalysisComparison

`compare_sequence_groups()`¶

gp3sequencespy.compare_sequence_groups ¶

compare_sequence_groups(
    data: Any,
    group_col: str,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    reference: Any = None,
    metrics: Sequence[str] = (
        "state",
        "transition",
        "length",
    ),
    include_self: bool = True,
    transition_separator: str = " -> ",
    zero_policy: str = "missing",
) -> GroupComparisonResult

`compare_sequence_hmms()`¶

gp3sequencespy.compare_sequence_hmms ¶

compare_sequence_hmms(
    *models: SequenceHMM | SequenceHMMMixture,
    **named_models: SequenceHMM | SequenceHMMMixture,
) -> pd.DataFrame

`compare_sequence_panel_changes()`¶

gp3sequencespy.compare_sequence_panel_changes ¶

compare_sequence_panel_changes(
    panel: SequencePanel,
    method: str = "levenshtein",
    normalise: str = "none",
    indel_cost: float = 1,
    substitution_cost: float = 1,
    substitution_matrix: Any = None,
    transition_smoothing: float = 0,
) -> pd.DataFrame

`compare_sequence_subsequences()`¶

gp3sequencespy.compare_sequence_subsequences ¶

compare_sequence_subsequences(
    occurrences: DataFrame,
    group_col: str,
    test: str = "auto",
    p_adjust: str = "BH",
    min_sequence_count: int = 1,
) -> pd.DataFrame

`compute_sequence_distance()`¶

gp3sequencespy.compute_sequence_distance ¶

compute_sequence_distance(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    method: str = "levenshtein",
    indel_cost: float = 1,
    substitution_cost: float = 1,
    substitution_matrix: Any = None,
    transition_smoothing: float = 0,
    normalise: str = "none",
) -> SequenceDistanceResult

`create_consensus_sequence()`¶

gp3sequencespy.create_consensus_sequence ¶

create_consensus_sequence(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    group_cols: Sequence[str] | str | None = None,
    weight_col: str | None = None,
    missing_state_policy: str = "exclude",
    missing_state_label: str = "<MISSING>",
    tie_method: str = "first",
    state_levels: Sequence[Any] | None = None,
    min_support: int = 1,
) -> pd.DataFrame

`create_sequence_cluster_ensemble()`¶

gp3sequencespy.create_sequence_cluster_ensemble ¶

create_sequence_cluster_ensemble(
    *solutions: Any, k: int, linkage: str = "average"
) -> SequenceClusterEnsemble

`create_transition_network()`¶

gp3sequencespy.create_transition_network ¶

create_transition_network(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    group_cols: Sequence[str] | str | None = None,
    order: int = 1,
    include_self: bool = True,
    normalise: str = "count",
    smoothing: float = 0,
    context_separator: str = " > ",
) -> pd.DataFrame

`declare_sequence_comparison_design()`¶

gp3sequencespy.declare_sequence_comparison_design ¶

declare_sequence_comparison_design(
    group_col: str,
    unit_col: str,
    design: str = "observational",
    pair_col: str | None = None,
    cluster_col: str | None = None,
) -> SequenceComparisonDesign

`decode_covariate_sequence_states()`¶

gp3sequencespy.decode_covariate_sequence_states ¶

decode_covariate_sequence_states(
    model: CovariateSequenceHMM,
    data: Any = None,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    method: str = "viterbi",
) -> pd.DataFrame

`decode_multichannel_sequence_states()`¶

gp3sequencespy.decode_multichannel_sequence_states ¶

decode_multichannel_sequence_states(
    model: MultichannelSequenceHMM,
    data: Any = None,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    channel_cols: Sequence[str] | None = None,
    method: str = "viterbi",
) -> pd.DataFrame

`decode_sequence_states()`¶

gp3sequencespy.decode_sequence_states ¶

decode_sequence_states(
    model: SequenceHMM | SequenceHMMMixture,
    data: Any = None,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    method: str = "viterbi",
    component: int | None = None,
) -> pd.DataFrame

`detect_transition_communities()`¶

gp3sequencespy.detect_transition_communities ¶

detect_transition_communities(
    network: DataFrame,
    method: str = "label_propagation",
    max_iter: int = 100,
    seed: int = 1,
) -> pd.DataFrame

`encode_sequence_data()`¶

gp3sequencespy.encode_sequence_data ¶

encode_sequence_data(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
    state_levels: Sequence[Any] | None = None,
    prefix: str = "S",
    width: int | None = None,
) -> EncodingResult

Create deterministic state integer and labelled encodings.

`extract_representative_sequences()`¶

gp3sequencespy.extract_representative_sequences ¶

extract_representative_sequences(
    clustering: Any,
    distance: Any = None,
    n_per_cluster: int = 1,
) -> pd.DataFrame

`extract_sequence_ngrams()`¶

gp3sequencespy.extract_sequence_ngrams ¶

extract_sequence_ngrams(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
    min_length: int = 2,
    max_length: int = 3,
    overlap: str = "allow",
    separator: str = " > ",
    state_levels: Sequence[Any] | None = None,
) -> MotifExtractionResult

`extract_sequence_subsequences()`¶

gp3sequencespy.extract_sequence_subsequences ¶

extract_sequence_subsequences(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    metadata_cols: Sequence[str] | str | None = None,
    min_length: int = 2,
    max_length: int = 5,
    max_gap: float = np.inf,
    max_span: float = np.inf,
    repeated_state_policy: str = "preserve",
    separator: str = " > ",
    max_combinations_per_sequence: int = 100000,
) -> pd.DataFrame

`filter_sequence_motifs()`¶

gp3sequencespy.filter_sequence_motifs ¶

filter_sequence_motifs(
    x: Any,
    min_occurrences: int = 1,
    min_sequences: int = 1,
    min_prevalence: float = 0,
    motif_lengths: Sequence[int] | None = None,
    top_n: int | None = None,
    rank_by: str = "sequence_prevalence",
    ties: str = "include",
) -> MotifFilterResult

`filter_sequence_subsequences()`¶

gp3sequencespy.filter_sequence_subsequences ¶

filter_sequence_subsequences(
    summary: DataFrame,
    min_sequences: int = 1,
    min_prevalence: float = 0,
    max_mean_gap: float = np.inf,
    top_n: int | None = None,
    ties: str = "include",
) -> pd.DataFrame

`fit_covariate_sequence_hmm()`¶

gp3sequencespy.fit_covariate_sequence_hmm ¶

fit_covariate_sequence_hmm(
    data: Any,
    n_states: int,
    initial_covariate_cols: Sequence[str] | None = None,
    transition_covariate_cols: Sequence[str] | None = None,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    symbol_levels: Sequence[str] | None = None,
    state_names: Sequence[str] | None = None,
    emission_probs=None,
    max_iter: int = 100,
    inner_maxit: int = 100,
    tolerance: float = 1e-06,
    pseudocount: float = 1e-06,
    ridge: float = 1e-06,
    seed: int = 1,
    keep_posteriors: bool = False,
) -> CovariateSequenceHMM

`fit_higher_order_transition_model()`¶

gp3sequencespy.fit_higher_order_transition_model ¶

fit_higher_order_transition_model(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    order: int = 2,
    smoothing: float = 0.5,
    backoff: bool = True,
    context_separator: str = " > ",
) -> HigherOrderTransitionModel

`fit_multichannel_sequence_hmm()`¶

gp3sequencespy.fit_multichannel_sequence_hmm ¶

fit_multichannel_sequence_hmm(
    data: Any,
    n_states: int,
    channel_cols: Sequence[str],
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    symbol_levels=None,
    state_names: Sequence[str] | None = None,
    initial_probs=None,
    transition_probs=None,
    emission_probs=None,
    max_iter: int = 200,
    tolerance: float = 1e-06,
    pseudocount: float = 1e-06,
    seed: int = 1,
    keep_posteriors: bool = False,
) -> MultichannelSequenceHMM

`fit_sequence_hmm()`¶

gp3sequencespy.fit_sequence_hmm ¶

fit_sequence_hmm(
    data: Any,
    n_states: int,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    symbol_levels: Sequence[str] | None = None,
    state_names: Sequence[str] | None = None,
    initial_probs=None,
    transition_probs=None,
    emission_probs=None,
    max_iter: int = 200,
    tolerance: float = 1e-06,
    pseudocount: float = 1e-06,
    seed: int = 1,
    keep_posteriors: bool = False,
) -> SequenceHMM

`fit_sequence_hmm_mixture()`¶

gp3sequencespy.fit_sequence_hmm_mixture ¶

fit_sequence_hmm_mixture(
    data: Any,
    n_components: int,
    n_states: int | Sequence[int],
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    symbol_levels: Sequence[str] | None = None,
    max_iter: int = 200,
    inner_initial_iter: int = 20,
    tolerance: float = 1e-06,
    pseudocount: float = 1e-06,
    seed: int = 1,
) -> SequenceHMMMixture

`fit_time_varying_sequence_model()`¶

gp3sequencespy.fit_time_varying_sequence_model ¶

fit_time_varying_sequence_model(
    data: Any,
    group_col: str,
    participant_id_col: str,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    time_col: str | None = None,
    outcome: str = "state",
    target_state: str | None = None,
    from_state: str | None = None,
    to_state: str | None = None,
    k: int = 5,
    method: str = "REML",
    include_random_effect: bool = True,
) -> TimeVaryingSequenceModel

`format_consensus_sequence()`¶

gp3sequencespy.format_consensus_sequence ¶

format_consensus_sequence(
    consensus: DataFrame,
    separator: str = " -> ",
    include_order: bool = False,
    include_agreement: bool = False,
    digits: int = 3,
) -> pd.DataFrame

`format_sequence_motif_positions()`¶

gp3sequencespy.format_sequence_motif_positions ¶

format_sequence_motif_positions(
    x: MotifPositionResult,
    digits: int = 3,
    position_units: str = "proportion",
    include_rank: bool = True,
) -> dict[str, Any]

`format_sequence_motifs()`¶

gp3sequencespy.format_sequence_motifs ¶

format_sequence_motifs(
    x: Any,
    digits: int = 3,
    prevalence: str = "proportion",
    include_rank: bool = True,
    rank_by: str = "sequence_prevalence",
    ties: str = "min",
    include_ids: bool = True,
) -> FormattedTableResult

`format_sequence_paths()`¶

gp3sequencespy.format_sequence_paths ¶

format_sequence_paths(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
    separator: str = " > ",
    collapse_repeats: bool = False,
) -> PathFormatResult

`plot_consensus_sequence()`¶

gp3sequencespy.plot_consensus_sequence ¶

plot_consensus_sequence(
    consensus: DataFrame,
    type: str = "agreement",
    group: Any = None,
    main: str | None = None,
    xlab: str = "Sequence position",
    ylab: str | None = None,
    *,
    ax=None,
    **kwargs,
)

`plot_multichannel_sequence_hmm()`¶

gp3sequencespy.plot_multichannel_sequence_hmm ¶

plot_multichannel_sequence_hmm(
    model: MultichannelSequenceHMM,
    channel: str | None = None,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_cluster_silhouette()`¶

gp3sequencespy.plot_sequence_cluster_silhouette ¶

plot_sequence_cluster_silhouette(
    clustering: Any,
    distance: Any = None,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_distance_heatmap()`¶

gp3sequencespy.plot_sequence_distance_heatmap ¶

plot_sequence_distance_heatmap(
    distance: Any,
    order_by: Any = None,
    palette: str = "Viridis",
    show_labels: bool = True,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_entropy()`¶

gp3sequencespy.plot_sequence_entropy ¶

plot_sequence_entropy(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    base: float = 2,
    normalise: bool = True,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_group_comparison()`¶

gp3sequencespy.plot_sequence_group_comparison ¶

plot_sequence_group_comparison(
    comparison: GroupComparisonResult,
    component: str = "state",
    measure: str | None = None,
    top_n: int = 12,
    main: str | None = None,
    xlab: str | None = None,
    ylab: str | None = None,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_group_inference()`¶

gp3sequencespy.plot_sequence_group_inference ¶

plot_sequence_group_inference(
    inference: SequenceGroupInference,
    type: str = "permutation",
    *,
    ax=None,
    **kwargs,
) -> SequenceGroupInference

`plot_sequence_index()`¶

gp3sequencespy.plot_sequence_index ¶

plot_sequence_index(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    sort_by: str = "input",
    state_levels: Sequence[str] | None = None,
    palette: str = "Dark 3",
    show_sequence_labels: bool = True,
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_motif_positions()`¶

gp3sequencespy.plot_sequence_motif_positions ¶

plot_sequence_motif_positions(
    x,
    motifs: Sequence[str] | str | None = None,
    position: str = "start",
    scale: str = "absolute",
    top_n: int = 10,
    display: str = "strip",
    *,
    ax=None,
)

`plot_sequence_motifs()`¶

gp3sequencespy.plot_sequence_motifs ¶

plot_sequence_motifs(
    x,
    metric: str = "sequence_prevalence",
    top_n: int = 20,
    motif_lengths: Sequence[int] | None = None,
    ties: str = "include",
    horizontal: bool = True,
    *,
    ax=None,
)

`plot_sequence_panel_changes()`¶

gp3sequencespy.plot_sequence_panel_changes ¶

plot_sequence_panel_changes(
    changes: DataFrame,
    metric: str = "distance",
    type: str = "individual",
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_state_distribution()`¶

gp3sequencespy.plot_sequence_state_distribution ¶

plot_sequence_state_distribution(
    data: Any,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    proportion: bool = True,
    state_levels: Sequence[str] | None = None,
    palette: str = "Dark 3",
    *,
    ax=None,
    **kwargs,
)

`plot_sequence_subsequences()`¶

gp3sequencespy.plot_sequence_subsequences ¶

plot_sequence_subsequences(
    x: DataFrame,
    metric: str = "sequence_prevalence",
    top_n: int = 10,
    decreasing: bool = True,
    *,
    ax=None,
    **kwargs,
) -> pd.DataFrame

`plot_time_varying_sequence_model()`¶

gp3sequencespy.plot_time_varying_sequence_model ¶

plot_time_varying_sequence_model(
    model: TimeVaryingSequenceModel,
    time: Sequence[float] | None = None,
    level: float = 0.95,
    show_interval: bool = True,
    *,
    ax=None,
    **kwargs,
)

`plot_transition_network()`¶

gp3sequencespy.plot_transition_network ¶

plot_transition_network(
    network: DataFrame,
    weight_col: str = "weight",
    minimum_weight: float = 0,
    vertex_cex: float = 1,
    edge_scale: float = 5,
    *,
    ax=None,
    **kwargs,
)

`predict_covariate_transition_probabilities()`¶

gp3sequencespy.predict_covariate_transition_probabilities ¶

predict_covariate_transition_probabilities(
    model: CovariateSequenceHMM, newdata: DataFrame
) -> pd.DataFrame

`predict_next_state()`¶

gp3sequencespy.predict_next_state ¶

predict_next_state(
    model: HigherOrderTransitionModel,
    history: Sequence[str] | str,
    top_n: int | None = None,
) -> pd.DataFrame

`predict_time_varying_sequence_model()`¶

gp3sequencespy.predict_time_varying_sequence_model ¶

predict_time_varying_sequence_model(
    model: TimeVaryingSequenceModel,
    time: Sequence[float] | None = None,
    groups: Sequence[str] | None = None,
    level: float = 0.95,
) -> pd.DataFrame

`prepare_gp3tools_sequences()`¶

gp3sequencespy.prepare_gp3tools_sequences ¶

prepare_gp3tools_sequences(
    data: Any,
    sequence_id_col: str | None = None,
    order_col: str | None = None,
    state_col: str | None = None,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | str | None = None,
    **kwargs: Any,
)

`prepare_sequence_data()`¶

gp3sequencespy.prepare_sequence_data ¶

prepare_sequence_data(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
    missing_state_policy: str = "error",
    duplicate_position_policy: str = "error",
    repeated_state_policy: str = "preserve",
    zero_duration_policy: str = "preserve",
    unknown_state_policy: str = "preserve",
    unused_state_levels: str = "preserve",
) -> PrepareResult

`prepare_sequence_panel()`¶

gp3sequencespy.prepare_sequence_panel ¶

prepare_sequence_panel(
    data: Any,
    panel_id_col: str,
    occasion_col: str,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    metadata_cols: Sequence[str] | str | None = None,
    require_unique_occasions: bool = True,
) -> SequencePanel

`sequence_capabilities()`¶

gp3sequencespy.sequence_capabilities ¶

sequence_capabilities(
    include_optional: bool = True,
    check_versions: bool = True,
) -> pd.DataFrame

`summarise_consensus_agreement()`¶

gp3sequencespy.summarise_consensus_agreement ¶

summarise_consensus_agreement(
    consensus: DataFrame,
    by: str = "overall",
    threshold: float = 0.5,
) -> pd.DataFrame

`summarise_covariate_sequence_hmm()`¶

gp3sequencespy.summarise_covariate_sequence_hmm ¶

summarise_covariate_sequence_hmm(
    model: CovariateSequenceHMM,
) -> dict[str, pd.DataFrame]

`summarise_multichannel_sequence_hmm()`¶

gp3sequencespy.summarise_multichannel_sequence_hmm ¶

summarise_multichannel_sequence_hmm(
    model: MultichannelSequenceHMM,
) -> dict[str, Any]

`summarise_sequence_cluster_stability()`¶

gp3sequencespy.summarise_sequence_cluster_stability ¶

summarise_sequence_cluster_stability(
    bootstrap: SequenceClusterBootstrap,
    threshold: float = 0.8,
) -> dict[str, Any]

`summarise_sequence_distance()`¶

gp3sequencespy.summarise_sequence_distance ¶

summarise_sequence_distance(
    distance: Any,
) -> dict[str, Any]

`summarise_sequence_group_inference()`¶

gp3sequencespy.summarise_sequence_group_inference ¶

summarise_sequence_group_inference(
    inference: SequenceGroupInference,
) -> dict[str, Any]

`summarise_sequence_hmm()`¶

gp3sequencespy.summarise_sequence_hmm ¶

summarise_sequence_hmm(
    model: SequenceHMM | SequenceHMMMixture,
) -> dict[str, Any]

`summarise_sequence_motif_positions()`¶

gp3sequencespy.summarise_sequence_motif_positions ¶

summarise_sequence_motif_positions(
    x: MotifExtractionResult,
    position: str = "start",
    scale: str = "absolute",
    by: Sequence[str] | str | None = None,
) -> MotifPositionResult

`summarise_sequence_motifs()`¶

gp3sequencespy.summarise_sequence_motifs ¶

summarise_sequence_motifs(
    x: MotifExtractionResult,
) -> MotifSummaryResult

`summarise_sequence_panel()`¶

gp3sequencespy.summarise_sequence_panel ¶

summarise_sequence_panel(
    panel: SequencePanel,
) -> dict[str, Any]

`summarise_sequence_states()`¶

gp3sequencespy.summarise_sequence_states ¶

summarise_sequence_states(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
) -> StateSummaryResult

`summarise_sequence_subsequences()`¶

gp3sequencespy.summarise_sequence_subsequences ¶

summarise_sequence_subsequences(
    occurrences: DataFrame,
) -> pd.DataFrame

`summarise_sequence_transitions()`¶

gp3sequencespy.summarise_sequence_transitions ¶

summarise_sequence_transitions(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
    include_self: bool = True,
) -> TransitionSummaryResult

`summarise_time_varying_sequence_model()`¶

gp3sequencespy.summarise_time_varying_sequence_model ¶

summarise_time_varying_sequence_model(
    model: TimeVaryingSequenceModel,
) -> dict[str, Any]

`summarise_transition_centrality()`¶

gp3sequencespy.summarise_transition_centrality ¶

summarise_transition_centrality(
    network: DataFrame,
    directed: bool = True,
    pagerank_damping: float = 0.85,
    pagerank_tolerance: float = 1e-10,
    pagerank_max_iter: int = 1000,
) -> pd.DataFrame

`test_sequence_group_difference()`¶

gp3sequencespy.test_sequence_group_difference ¶

test_sequence_group_difference(
    data: Any,
    design: SequenceComparisonDesign,
    metric: str = "sequence_length",
    target_state: str | None = None,
    target_subsequence: str | None = None,
    sequence_id_col: str = "sequence_id",
    order_col: str = "sequence_order",
    state_col: str = "state",
    separator: str = " > ",
    n_permutations: int = 999,
    alternative: str = "two.sided",
    seed: int = 1,
) -> SequenceGroupInference

`validate_sequence_clusters()`¶

gp3sequencespy.validate_sequence_clusters ¶

validate_sequence_clusters(
    clustering: Any, distance: Any = None
) -> dict[str, pd.DataFrame]

`validate_sequence_data()`¶

gp3sequencespy.validate_sequence_data ¶

validate_sequence_data(
    data: DataFrame,
    sequence_id_col: str,
    order_col: str,
    state_col: str,
    duration_col: str | None = None,
    metadata_cols: Sequence[str] | None = None,
    expected_states: Sequence[Any] | None = None,
) -> ValidationResult