pm4py.algo.querying.llm.abstractions package#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

Submodules#

pm4py.algo.querying.llm.abstractions.case_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.case_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_CASE_ATTRIBUTES = 'include_case_attributes'#
INCLUDE_EVENT_ATTRIBUTES = 'include_event_attributes'#
INCLUDE_TIMESTAMP = 'include_timestamp'#
INCLUDE_HEADER = 'include_header'#
ACTIVITY_KEY = 'pm4py:param:activity_key'#
TIMESTAMP_KEY = 'pm4py:param:timestamp_key'#
pm4py.algo.querying.llm.abstractions.case_to_descr.apply(case: Trace, parameters: Optional[Dict[Any, Any]] = None) str[source]#

Provides a textual abstraction of a single case (Trace object) of a traditional event log

Parameters#

case

Single case (Trace object) of a traditional event log

parameters

Parameters of the method, including: - Parameters.INCLUDING_CASE_ATTRIBUTES - Parameters.INCLUDE_EVENT_ATTRIBUTES - Parameters.INCLUDE_TIMESTAMP - Parameters.INCLUDE_HEADER => includes the header (or not) in the response) - Parameters.ACTIVITY_KEY => the attribute to be used as activity - Parameters.TIMESTAMP_KEY => the attribute to be used as timestamp

Returns#

stru

Textual abstraction of the case

pm4py.algo.querying.llm.abstractions.declare_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.declare_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_HEADER = 'include_header'#
pm4py.algo.querying.llm.abstractions.declare_to_descr.apply(declare: Dict[str, Dict[Any, Dict[str, int]]], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Gets a textual abstraction of a DECLARE model

Parameters#

declare

DECLARE model

parameters

Possible parameters of the algorithm, including: - Parameters.INCLUDE_HEADER => include the header of the response

Returns#

stru

Textual abstraction

pm4py.algo.querying.llm.abstractions.log_to_cols_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.log_to_cols_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

MAX_LEN = 'max_len'#
CASE_ID_KEY = 'pm4py:param:case_id_key'#
pm4py.algo.querying.llm.abstractions.log_to_cols_descr.apply(log_obj: Union[EventLog, EventStream, DataFrame], parameters: Optional[Dict[Any, Any]] = None) str[source]#

pm4py.algo.querying.llm.abstractions.log_to_dfg_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.log_to_dfg_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_FREQUENCY = 'include_frequency'#
INCLUDE_PERFORMANCE = 'include_performance'#
MAX_LEN = 'max_len'#
RELATIVE_FREQUENCY = 'relative_frequency'#
RESPONSE_HEADER = 'response_header'#
PRIMARY_PERFORMANCE_AGGREGATION = 'primary_performance_aggregation'#
SECONDARY_PERFORMANCE_AGGREGATION = 'secondary_performance_aggregation'#
ACTIVITY_KEY = 'pm4py:param:activity_key'#
TIMESTAMP_KEY = 'pm4py:param:timestamp_key'#
CASE_ID_KEY = 'pm4py:param:case_id_key'#
pm4py.algo.querying.llm.abstractions.log_to_dfg_descr.abstraction_from_frequency_performance_dfg(freq_dfg: Dict[Tuple[str, str], int], perf_dfg: Dict[Tuple[str, str], Dict[str, float]], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Obtains the abstraction starting from the knowledge of the frequency of the paths, and their performance.

Minimal viable example:

import pm4py from pm4py.algo.querying.llm.abstractions import log_to_dfg_descr

log = pm4py.read_xes(‘tests/input_data/running-example.xes’) freq_dfg, sa, ea = pm4py.discover_dfg(log) perf_dfg, sa, ea = pm4py.discover_performance_dfg(log) print(log_to_dfg_descr.abstraction_from_frequency_performance_dfg(freq_dfg, perf_dfg))

Parameters#

freq_dfg

Dictionary associating to each path its frequency

perf_dfg

Dictionary associating to each path its performance. A path (‘A’, ‘B’) is associated to a dictionary containing performance metrics, i.e. (‘A’, ‘B’): {‘mean’: 86400, ‘stdev’: 86400} means that: - the average time between the activities A and B is 1 day - also the standard deviation of the times between A and B is 1 day

parameters
Optional parameters of the algorithm, including:
  • Parameters.RELATIVE_FREQUENCY => (boolean) decides if the frequency DFG should be normalized to a relative

    frequency

  • Parameters.INCLUDE_FREQUENCY => includes the frequency of the arcs in the textual abstraction

  • Parameters.INCLUDE_PERFORMANCE => includes the performance of the arcs in the textual abstraction

  • Parameters.MAX_LEN => desidered length of the textual abstraction

  • Parameters.RESPONSE_HEADER => includes an header in the textual abstraction, which explains the context

  • Parameters.PRIMARY_PERFORMANCE_AGGREGATION => primary performance metric to be used to express the performance of the arcs (e.g., mean). Available options: mean, median, stdev, min, max, sum

  • Parameters.SECONDARY_PERFORMANCE_AGGREGATION => secondary performance metric to be used to express the performance of the arcs (e.g., stdev). Available options: mean, median, stdev, min, max, sum

Returns#

textual_abstraction

Textual abstraction

pm4py.algo.querying.llm.abstractions.log_to_dfg_descr.apply(log_obj: Union[EventLog, EventStream, DataFrame], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Gets the textual abstraction of the directly-follows graph computed on the provided log object.

Minimal viable example:

import pm4py from pm4py.algo.querying.llm.abstractions import log_to_dfg_descr

log = pm4py.read_xes(‘tests/input_data/running-example.xes’) print(log_to_dfg_descr.apply(log))

Parameters#

log_obj

Log object (event log / Pandas dataframe)

parameters
Optional Parameters of the algorithm, including:
  • Parameters.ACTIVITY_KEY => the attribute to be used as activity

  • Parameters.TIMESTAMP_KEY => the attribute to be used as timestamp

  • Parameters.CASE_ID_KEY => the attribute to be used as case ID

  • Parameters.RELATIVE_FREQUENCY => (boolean) decides if the frequency DFG should be normalized to a relative

    frequency

  • Parameters.INCLUDE_FREQUENCY => includes the frequency of the arcs in the textual abstraction

  • Parameters.INCLUDE_PERFORMANCE => includes the performance of the arcs in the textual abstraction

  • Parameters.MAX_LEN => desidered length of the textual abstraction

  • Parameters.RESPONSE_HEADER => includes an header in the textual abstraction, which explains the context

  • Parameters.PRIMARY_PERFORMANCE_AGGREGATION => primary performance metric to be used to express the performance of the arcs (e.g., mean). Available options: mean, median, stdev, min, max, sum

  • Parameters.SECONDARY_PERFORMANCE_AGGREGATION => secondary performance metric to be used to express the performance of the arcs (e.g., stdev). Available options: mean, median, stdev, min, max, sum

Returns#

textual_abstraction

Textual abstraction

pm4py.algo.querying.llm.abstractions.log_to_fea_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.log_to_fea_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_HEADER = 'include_header'#
MAX_LEN = 'max_len'#
pm4py.algo.querying.llm.abstractions.log_to_fea_descr.textual_abstraction_from_fea_df(fea_df: DataFrame, parameters: Optional[Dict[Any, Any]] = None) str[source]#

Returns the textual abstraction of ML features already encoded in a feature table

Minimum viable example:

import pm4py from pm4py.algo.querying.llm.abstractions import log_to_fea_descr

log = pm4py.read_xes(“tests/input_data/receipt.xes”, return_legacy_log_object=True) fea_df = pm4py.extract_features_dataframe(log) text_abstr = log_to_fea_descr.textual_abstraction_from_fea_df(fea_df) print(text_abstr)

Parameters#

fea_df

Feature table (numeric features; stored as Pandas dataframe)

parameters

Parameters that should be provided to the feature extraction, plus: - Parameters.INCLUDE_HEADER => includes a descriptive header in the returned text - Parameters.MAX_LEN => maximum length of the provided text (if necessary, only the most meaningful features are kept)

Returns#

stru

Textual abstraction

pm4py.algo.querying.llm.abstractions.log_to_fea_descr.apply(log: Union[EventLog, EventStream, DataFrame], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Returns the textual abstraction of ML features extracted from a traditional event log object.

Minimum viable example:

import pm4py from pm4py.algo.querying.llm.abstractions import log_to_fea_descr

log = pm4py.read_xes(“tests/input_data/receipt.xes”, return_legacy_log_object=True) text_abstr = log_to_fea_descr.apply(log) print(text_abstr)

Parameters#

log

Event log / Pandas dataframe

parameters

Parameters that should be provided to the feature extraction, plus: - Parameters.INCLUDE_HEADER => includes a descriptive header in the returned text - Parameters.MAX_LEN => maximum length of the provided text (if necessary, only the most meaningful features are kept)

Returns#

stru

Textual abstraction

pm4py.algo.querying.llm.abstractions.log_to_variants_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.log_to_variants_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_FREQUENCY = 'include_frequency'#
INCLUDE_PERFORMANCE = 'include_performance'#
MAX_LEN = 'max_len'#
RELATIVE_FREQUENCY = 'relative_frequency'#
RESPONSE_HEADER = 'response_header'#
PRIMARY_PERFORMANCE_AGGREGATION = 'primary_performance_aggregation'#
SECONDARY_PERFORMANCE_AGGREGATION = 'secondary_performance_aggregation'#
ACTIVITY_KEY = 'pm4py:param:activity_key'#
TIMESTAMP_KEY = 'pm4py:param:timestamp_key'#
CASE_ID_KEY = 'pm4py:param:case_id_key'#
pm4py.algo.querying.llm.abstractions.log_to_variants_descr.abstraction_from_variants_freq_perf_list(vars_list: List[Tuple[List[str], int, float, float]], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Obtains a textual abstraction from a list of variants provided along their frequency and performance values. Each variant of the list is expressed in the form:

((‘A’, ‘B’, ‘C’), 1000, 86400.0, 172800.0)

where (‘A’, ‘B’, ‘C’) is the tuple of activities executed in the variant, 1000 is the number of occurrences of this variant in the event log, 86400.0 is an aggregation (mean) of the throughput times of the cases belonging to this variant, 172800.0 is an aggregation (stdev, so standard deviation) of the throughput times of these cases.

Minimal viable example:

from pm4py.algo.querying.llm.abstractions import log_to_variants_descr

vars_list = [((‘A’, ‘B’, ‘C’), 1000, 86400.0, 172800.0), ((‘A’, ‘B’), 500, 3600.0, 43200.0)] print(log_to_variants_descr.abstraction_from_variants_freq_perf_list(vars_list))

Parameters#

vars_list

List of variants, expressed as explained above

parameters
Optional parameters of the algorithm, including:
  • Parameters.RELATIVE_FREQUENCY => decides if the the frequency of the variants should be normalized to a relative

    frequency

  • Parameters.PRIMARY_PERFORMANCE_AGGREGATION => primary performance metric to be used to express the performance of the arcs (e.g., mean). Available options: mean, median, stdev, min, max, sum

  • Parameters.SECONDARY_PERFORMANCE_AGGREGATION => secondary performance metric to be used to express the performance of the arcs (e.g., stdev). Available options: mean, median, stdev, min, max, sum

  • Parameters.MAX_LEN => desidered length of the textual abstraction

  • Parameters.RESPONSE_HEADER => includes an header in the textual abstraction, which explains the context

  • Parameters.INCLUDE_FREQUENCY => includes the frequency of the arcs in the textual abstraction

  • Parameters.INCLUDE_PERFORMANCE => includes the performance of the arcs in the textual abstraction

Returns#

textual_abstraction

Textual abstraction of the variants

pm4py.algo.querying.llm.abstractions.log_to_variants_descr.compute_perf_aggregation(perf_values: List[float], perf_agg: str) float[source]#

Computes an aggregation of a list of performance values

Minimal viable example:

compute_perf_aggregation([3600.0, 7200.0], ‘mean’)

Parameters#

perf_values

List of performance values

perf_agg

Desired aggregation (mean, median, stdev, sum, min, max)

Returns#

agg_value

Aggregated value

pm4py.algo.querying.llm.abstractions.log_to_variants_descr.apply(log_obj: Union[EventLog, EventStream, DataFrame], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Gets the textual abstraction of the variants of a specified log object.

Minimal viable example:

import pm4py from pm4py.algo.querying.llm.abstractions import log_to_variants_descr

log = pm4py.read_xes(‘tests/input_data/running-example.xes’) print(log_to_variants_descr.apply(log))

Parameters#

log_obj

Log object

parameters

Optional parameters of the algorithm, including: - Parameters.ACTIVITY_KEY => the attribute of the log to be used as activity - Parameters.TIMESTAMP_KEY => the attribute of the log to be used as timestamp - Parameters.CASE_ID_KEY => the attribute of the log to be used as case identifier - Parameters.RELATIVE_FREQUENCY => decides if the the frequency of the variants should be normalized to a relative

frequency

  • Parameters.PRIMARY_PERFORMANCE_AGGREGATION => primary performance metric to be used to express the performance of the arcs (e.g., mean). Available options: mean, median, stdev, min, max, sum

  • Parameters.SECONDARY_PERFORMANCE_AGGREGATION => secondary performance metric to be used to express the performance of the arcs (e.g., stdev). Available options: mean, median, stdev, min, max, sum

Returns#

textual_abstraction

Textual abstraction of the variants of an event log object

pm4py.algo.querying.llm.abstractions.logske_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.logske_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_HEADER = 'include_header'#
pm4py.algo.querying.llm.abstractions.logske_to_descr.apply(lsk: Dict[str, Any], parameters: Optional[Dict[Any, Any]] = None) str[source]#

pm4py.algo.querying.llm.abstractions.net_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.net_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

RESPONSE_HEADER = 'response_header'#
pm4py.algo.querying.llm.abstractions.net_to_descr.apply(net: PetriNet, im: Marking, fm: Marking, parameters: Optional[Dict[Any, Any]] = None) str[source]#

Provides the description of an accepting Petri net

Parameters#

net

Petri net

im

Initial marking

fm

Final marking

parameters

Possible parameters of the algorithm, including: - Parameters.INCLUDE_HEADER => includes the header

Returns#

stru

String representation of the given accepting Petri net

pm4py.algo.querying.llm.abstractions.ocel_fea_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.ocel_fea_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_HEADER = 'include_header'#
MAX_LEN = 'max_len'#
DEBUG = 'debug'#
ENABLE_OBJECT_LIFECYCLE_PATHS = 'enable_object_lifecycle_paths'#
pm4py.algo.querying.llm.abstractions.ocel_fea_descr.textual_abstraction_from_fea_df(fea_df: DataFrame, parameters: Optional[Dict[Any, Any]] = None) str[source]#
pm4py.algo.querying.llm.abstractions.ocel_fea_descr.apply(ocel: OCEL, obj_type: str, parameters: Optional[Dict[Any, Any]] = None) str[source]#

pm4py.algo.querying.llm.abstractions.ocel_ocdfg_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.ocel_ocdfg_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

MAX_LEN = 'max_len'#
INCLUDE_HEADER = 'include_header'#
INCLUDE_PERFORMANCE = 'include_performance'#
pm4py.algo.querying.llm.abstractions.ocel_ocdfg_descr.apply(ocel: OCEL, parameters: Optional[Dict[Any, Any]] = None) str[source]#

pm4py.algo.querying.llm.abstractions.stream_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.stream_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

RESPONSE_HEADER = 'response_header'#
TIMESTAMP_KEY = 'pm4py:param:timestamp_key'#
MAX_LEN = 'max_len'#
pm4py.algo.querying.llm.abstractions.stream_to_descr.apply(log_obj: Union[EventLog, EventStream, DataFrame], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Given a log object, returns a representation of the (last) events of a stream corresponding to the log object.

Parameters#

log_obj

Log object

parameters

Parameters of the algorithm, including: - Parameters.RESPONSE_HEADER => includes the header in the response - Parameters.TIMESTAMP_KEY => the attribute to be used as timestamp - Parameters.MAX_LEN => maximum length of the resulting stream

Returns#

descr

String representing the stream of events

pm4py.algo.querying.llm.abstractions.tempprofile_to_descr module#

This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).

PM4Py is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

PM4Py is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with PM4Py. If not, see <https://www.gnu.org/licenses/>.

class pm4py.algo.querying.llm.abstractions.tempprofile_to_descr.Parameters(value)[source]#

Bases: Enum

An enumeration.

INCLUDE_HEADER = 'include_header'#
pm4py.algo.querying.llm.abstractions.tempprofile_to_descr.apply(temporal_profile: Dict[Tuple[str, str], Tuple[float, float]], parameters: Optional[Dict[Any, Any]] = None) str[source]#

Abstracts a temporal profile model to a string.

Parameters#

temporal_profile

Temporal profile

parameters

Parameters of the method, including: - Parameters.INCLUDE_HEADER => includes the header in the response

Returns#

text_abstr

Textual abstraction of the log skeleton