Add 'pm4py/' from commit '80970016c5e1e79af7c37df0dd88e17587fe7bcf'

git-subtree-dir: pm4py
git-subtree-mainline: 2c091203bedd9c2047dfb083690b2da242c2a0e8
git-subtree-split: 80970016c5e1e79af7c37df0dd88e17587fe7bcf

pm4py/.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sqlite filter=lfs diff=lfs merge=lfs -text
+*.xes.gz filter=lfs diff=lfs merge=lfs -text

pm4py/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ release ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ release ]
+  schedule:
+    - cron: '25 5 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

pm4py/.gitignore

@@ -0,0 +1,139 @@
+/.idea
+.vscode/
+
+*.mps
+*.sol
+*debug.log*
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Renovate bot
+renovate.json5

pm4py/Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.12.4-bookworm
+
+RUN apt-get update
+RUN apt-get -y upgrade
+RUN apt-get -y install aptitude locate apt-file nano vim git zip unzip wget graphviz curl gnupg gnupg2 tini iputils-ping unixodbc-dev
+RUN apt-get -y install gcc g++ flex bison pkg-config automake autoconf cmake
+RUN apt-get -y install python3-dev python3-pydot python3-tk
+RUN apt-get -y install libopenblas-dev liblapack-dev libboost-all-dev libncurses5-dev libtool libssl-dev libjemalloc-dev libboost-dev libboost-filesystem-dev libboost-system-dev libboost-regex-dev libxml2-dev libxslt-dev libfreetype6-dev libsuitesparse-dev libclang-16-dev llvm-16-dev libthrift-dev libfftw3-dev
+RUN python3 -m pip install --upgrade pip
+RUN pip3 install deprecation==2.1.0 graphviz==0.20.3 intervaltree==3.1.0 networkx==3.3 packaging==24.1 python-dateutil==2.9.0.post0 pytz==2024.1 setuptools==70.1.1 six==1.16.0 sortedcontainers==2.4.0 tzdata==2024.1 wheel==0.43.0 
+RUN pip3 install colorama==0.4.6 cycler==0.12.1 pydotplus==2.0.2 pyparsing==3.1.2 tqdm==4.66.4 
+RUN pip3 install lxml==5.2.2 numpy==2.0.0 pandas==2.2.2 scipy==1.14.0 
+RUN pip3 install contourpy==1.2.1 fonttools==4.53.0 kiwisolver==1.4.5 matplotlib==3.9.0 pillow==10.4.0 
+RUN pip3 install anyio==4.4.0 asttokens==2.4.1 attrs==23.2.0 certifi==2024.6.2 charset-normalizer==3.3.2 convertdate==2.4.0 decorator==5.1.1 distro==1.9.0 executing==2.0.1 h11==0.14.0 httpcore==1.0.5 httpx==0.27.0 idna==3.7 ipython==8.26.0 jedi==0.19.1 Jinja2==3.1.4 jsonpickle==3.2.2 jsonschema-specifications==2023.12.1 lunardate==0.2.2 MarkupSafe==2.1.5 matplotlib-inline==0.1.7 parso==0.8.4 prompt-toolkit==3.0.47 pure-eval==0.2.2 pydantic==2.7.4 Pygments==2.18.0 pyluach==2.2.0 PyMeeus==0.5.12 referencing==0.35.1 rpds-py==0.18.1 sniffio==1.3.1 stack-data==0.6.3 traitlets==5.14.3 typing_extensions==4.12.2 urllib3==2.2.2 wcwidth==0.2.13 
+RUN pip3 install jsonschema==4.22.0 openai==1.35.7 pyvis==0.3.2 requests==2.32.3 workalendar==17.0.0 
+RUN pip3 install -U meson-python==0.15.0 Cython==3.0.10 ninja==1.11.1.1 spin==0.8 build==1.2.1 setuptools_scm==8.0.4
+
+#RUN cd / && git clone https://github.com/numpy/numpy.git && cd /numpy && git submodule update --init && pip3 install .
+#RUN cd / && git clone https://github.com/pandas-dev/pandas.git && cd /pandas && pip3 install .
+#RUN cd / && git clone https://github.com/scipy/scipy.git && cd /scipy && git submodule update --init && pip3 install .
+#RUN cd / && git clone https://github.com/lxml/lxml.git && cd /lxml && pip3 install .
+#RUN cd / && git clone https://github.com/matplotlib/matplotlib.git && cd /matplotlib && pip3 install .
+#RUN cd / && git clone https://github.com/duckdb/duckdb.git && cd /duckdb && make && cd /duckdb/tools/pythonpkg && pip3 install .
+#RUN cd / && git clone https://github.com/apache/arrow.git && export ARROW_HOME=/dist && export LD_LIBRARY_PATH=/dist/lib:$LD_LIBRARY_PATH && export CMAKE_PREFIX_PATH=$ARROW_HOME:$CMAKE_PREFIX_PATH && cd /arrow/ && mkdir cpp/build && cd cpp/build && cmake -DCMAKE_INSTALL_PREFIX=$ARROW_HOME -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=Debug -DARROW_BUILD_TESTS=ON -DARROW_COMPUTE=ON -DARROW_CSV=ON -DARROW_DATASET=ON -DARROW_FILESYSTEM=ON -DARROW_HDFS=ON -DARROW_JSON=ON -DARROW_PARQUET=ON -DARROW_WITH_BROTLI=ON -DARROW_WITH_BZ2=ON -DARROW_WITH_LZ4=ON -DARROW_WITH_SNAPPY=ON -DARROW_WITH_ZLIB=ON -DARROW_WITH_ZSTD=ON -DPARQUET_REQUIRE_ENCRYPTION=ON .. && make -j4 && make install && cd /arrow/python && export PYARROW_WITH_PARQUET=1 && export PYARROW_WITH_DATASET=1 && export PYARROW_PARALLEL=4 && python3 setup.py build_ext --inplace && python3 setup.py install
+#RUN cd / && git clone https://github.com/python-greenlet/greenlet && cd /greenlet && pip3 install .
+#RUN cd / && git clone https://github.com/sqlalchemy/sqlalchemy.git && cd /sqlalchemy && pip3 install .
+#RUN cd / && git clone https://github.com/mkleehammer/pyodbc.git && cd /pyodbc && pip3 install .
+
+#RUN cd / && git clone https://github.com/scikit-learn/scikit-learn.git && cd /scikit-learn && pip3 install .
+#RUN cd / && git clone https://github.com/chuanconggao/PrefixSpan-py.git && cd /PrefixSpan-py && pip3 install .
+#RUN cd / && git clone https://github.com/wmayner/pyemd.git && cd /pyemd && pip3 install .
+#RUN cd / && wget https://ftp.gnu.org/gnu/glpk/glpk-5.0.tar.gz && tar xzvf glpk-5.0.tar.gz && cd /glpk-5.0 && ./configure && make && make install
+#RUN cd / && git clone https://github.com/cvxopt/cvxopt.git && cd /cvxopt && sed -i 's/BUILD_GLPK = 0/BUILD_GLPK = 1/' setup.py && python3 setup.py build && python3 setup.py install
+
+COPY . /app
+RUN cd /app && pip3 install --no-deps .

pm4py/MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include pm4py *.svg
+recursive-include pm4py *.html

pm4py/README.md

@@ -0,0 +1,62 @@
+# pm4py
+pm4py is a python library that supports (state-of-the-art) process mining algorithms in python. 
+It is open source (licensed under GPL) and intended to be used in both academia and industry projects.
+pm4py is a product of the Fraunhofer Institute for Applied Information Technology.
+
+## Documentation / API
+The full documentation of pm4py can be found at https://pm4py.fit.fraunhofer.de
+
+## First Example
+A very simple example, to whet your appetite:
+
+```python
+import pm4py
+
+if __name__ == "__main__":
+    log = pm4py.read_xes('<path-to-xes-log-file.xes>')
+    net, initial_marking, final_marking = pm4py.discover_petri_net_inductive(log)
+    pm4py.view_petri_net(net, initial_marking, final_marking, format="svg")
+```
+
+## Installation
+pm4py can be installed on Python 3.9.x / 3.10.x / 3.11.x / 3.12.x by invoking:
+*pip install -U pm4py*
+
+pm4py is also running on older Python environments with different requirements sets, including:
+- Python 3.8 (3.8.10): third_party/old_python_deps/requirements_py38.txt
+
+## Requirements
+pm4py depends on some other Python packages, with different levels of importance:
+* *Essential requirements*: numpy, pandas, deprecation, networkx
+* *Normal requirements* (installed by default with the pm4py package, important for mainstream usage): graphviz, intervaltree, lxml, matplotlib, pydotplus, pytz, scipy, tqdm
+* *Optional requirements* (not installed by default): requests, pyvis, jsonschema, workalendar, pyarrow, scikit-learn, polars, openai, pyemd, pyaudio, pydub, pygame, pywin32, pygetwindow, pynput
+
+## Release Notes
+To track the incremental updates, please refer to the *CHANGELOG* file.
+
+## Third Party Dependencies
+As scientific library in the Python ecosystem, we rely on external libraries to offer our features.
+In the */third_party* folder, we list all the licenses of our direct dependencies.
+Please check the */third_party/LICENSES_TRANSITIVE* file to get a full list of all transitive dependencies and the corresponding license.
+
+## Citing pm4py
+If you are using pm4py in your scientific work, please cite pm4py as follows:
+
+**Alessandro Berti, Sebastiaan van Zelst, Daniel Schuster**. (2023). *PM4Py: A process mining library for Python*. Software Impacts, 17, 100556. [DOI](https://doi.org/10.1016/j.simpa.2023.100556) | [Article Link](https://www.sciencedirect.com/science/article/pii/S2665963823000933)
+
+BiBTeX:
+
+```bibtex
+@article{pm4py,  
+title = {PM4Py: A process mining library for Python},  
+journal = {Software Impacts},  
+volume = {17},  
+pages = {100556},  
+year = {2023},  
+issn = {2665-9638},  
+doi = {https://doi.org/10.1016/j.simpa.2023.100556},  
+url = {https://www.sciencedirect.com/science/article/pii/S2665963823000933},  
+author = {Alessandro Berti and Sebastiaan van Zelst and Daniel Schuster},  
+}
+```
+

pm4py/docs/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 5eb7f31d57fb2354f38aa0b1fbc31deb
+tags: 645f666f9bcd5a90fca523b33c5a78b7

pm4py/docs/LICENSE_HEADER_GITHUB.txt

@@ -0,0 +1,16 @@
+'''
+    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/>.
+'''

pm4py/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = pm4py
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

pm4py/docs/README

@@ -0,0 +1,12 @@
+This document describes how to generate API documentation using sphinx.
+
+First, install sphinx (we assume you are able to do this via the official sphinx website).
+
+To generate the docs perform the following steps.
+	1. First create all the actuall .rst files that define all the documentation.
+	In cmd/terminal browse to the docs folder (this folder ;-)) and run:
+		> sphinx-apidoc --module-first -o source ../
+	You can optionally opt to choose to remove all the .rst files from the source folder (except for index.rst!!!!)
+	
+	2. Generate corresponding html files:
+		make html

pm4py/docs/header_script.py

@@ -0,0 +1,15 @@
+import glob
+
+if __name__ == '__main__':
+    LICENSE_HEADER_FILE_PATH = r'LICENSE_HEADER_GITHUB.txt'
+    with open(LICENSE_HEADER_FILE_PATH, 'r') as license_file:
+        license = license_file.read()
+        for filename in glob.iglob('../pm4py/' + '**/*.py', recursive=True):
+            with open(filename, 'r', encoding='utf-8') as original:
+                data = original.read()
+                if (data.find(license) == -1):
+                    with open(filename, 'w', encoding='utf-8') as modified:
+                        print('adding license to: ' + filename)
+                        modified.write(license + '\n' + data)
+                else:
+                    print('skipping: ' + filename)

pm4py/docs/make.bat

@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=pm4py
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

pm4py/docs/source/.gitignore

@@ -0,0 +1 @@
+generated/*

pm4py/docs/source/_static/css/custom.css

@@ -0,0 +1,7 @@
+.bd-header {
+	display: none;
+}
+
+.bd-footer {
+	display: none;
+}

pm4py/docs/source/api.rst

@@ -0,0 +1,683 @@
+API Reference
+=============
+This page provides an overview of all public ``pm4py`` objects, functions and methods. 
+
+Input (:mod:`pm4py.read`)
+---------------------------------
+``pm4py`` supports importing the following standardized *event data* format:
+
+  * ``.xes`` files (`xes-standard <https://xes-standard.org/>`_); General interchange format for event data. :meth:`pm4py.read.read_xes`
+
+In case an event log is stored as a ``.csv`` file, ``pandas`` can be used to directly import the event log as a ``data frame`` (`docs <https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html>`_).
+``.xes`` files are internally converted to a ``pandas dataframe``, which is the default data structure used by all algorithms implemented in ``pm4py``.
+
+Additional file formats that are currently supported by pm4py are:
+
+  * ``.bpmn`` files; File format specifying process models in the *BPMN* process modeling formalism :meth:`pm4py.read.read_bpmn`
+  * ``.dfg`` files; File format specifying *directly follows graphs* (also referred to as *process maps*) :meth:`pm4py.read.read_dfg`
+  * ``.pnml`` files; File format specifying *Petri net* models :meth:`pm4py.read.read_pnml`
+  * ``.ptml`` files; File format specifying *Process Tree* models :meth:`pm4py.read.read_ptml`
+
+Importing object-centric event logs is possible given the following formats:
+
+  * ``.csv`` specification :meth:`pm4py.read.read_ocel_csv`
+  * ``.jsonocel`` specification :meth:`pm4py.read.read_ocel_json`
+  * ``.xmlocel`` specification :meth:`pm4py.read.read_ocel_xml`
+  * ``.sqlite`` specification :meth:`pm4py.read.read_ocel_sqlite`
+
+Importing object-centric event logs (OCEL2.0) is possible given the following formats:
+
+  * ``.xmlocel`` specification :meth:`pm4py.read.read_ocel2_xml`
+  * ``.sqlite`` specification :meth:`pm4py.read.read_ocel2_sqlite`
+  * ``.jsonocel`` specification :meth:`pm4py.read.read_ocel2_json`
+
+
+Output (:mod:`pm4py.write`)
+-------------------------------------
+Similarly to event data importing, ``pm4py`` supports export functionalities to:
+
+  * ``.bpmn`` files,  :meth:`pm4py.write.write_bpmn`
+  * ``.dfg`` files,  :meth:`pm4py.write.write_dfg`
+  * ``.pnml`` files, :meth:`pm4py.write.write_pnml`
+  * ``.ptml`` files, :meth:`pm4py.write.write_ptml`
+  * ``.xes`` files. :meth:`pm4py.write.write_xes`
+
+Exporting object-centric event logs is possible to the following formats:
+
+  * ``.csv`` specification :meth:`pm4py.write.write_ocel_csv`
+  * ``.jsonocel`` specification :meth:`pm4py.write.write_ocel_json`
+  * ``.xmlocel`` specification :meth:`pm4py.write.write_ocel_xml`
+  * ``.sqlite`` specification :meth:`pm4py.write.write_ocel_sqlite`
+
+Exporting object-centric event logs (OCEL2.0) is possible to the following formats:
+
+  * ``.xmlocel`` specification :meth:`pm4py.write.write_ocel2_xml`
+  * ``.sqlite`` specification :meth:`pm4py.write.write_ocel2_sqlite`
+  * ``.jsonocel`` specification :meth:`pm4py.write.write_ocel2_json`
+
+
+Conversion (:mod:`pm4py.convert`)
+-------------------------------------
+Several conversions are available from/to different objects supported by ``pm4py``.
+The following conversions are currently available:
+
+  * :meth:`pm4py.convert.convert_to_bpmn` converts a process model to BPMN
+  * :meth:`pm4py.convert.convert_to_petri_net` converts a process model to Petri net
+  * :meth:`pm4py.convert.convert_to_process_tree` converts a process model to a process tree
+  * :meth:`pm4py.convert.convert_to_reachability_graph` converts a process model to a reachability graph
+  * :meth:`pm4py.convert.convert_log_to_ocel` converts an event log to an object-centric event log
+  * :meth:`pm4py.convert.convert_log_to_networkx` converts a traditional event log (dataframe) to a directed graph (NetworkX)
+  * :meth:`pm4py.convert.convert_ocel_to_networkx` converts an object-centric event log to a directed graph (NetworkX)
+  * :meth:`pm4py.convert.convert_petri_net_to_networkx` converts an accepting Petri net to a directed graph (NetworkX)
+  * :meth:`pm4py.convert.convert_petri_net_type` change the Petri net internal type
+
+
+Process Discovery (:mod:`pm4py.discovery`)
+------------------------------------------
+Process Discovery algorithms discover a process model that describes the process execution, as stored in the event log.
+``pm4py`` implements a variety of different process discovery algorithms.
+These different algorithms return different kinds of models, i.e., models with *imprecise execution semantics*, *procedural process models* and *declarative process models*.
+Among the models with *imprecise execution semantics*, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.discovery.discover_dfg`; discovers a *directly follows graph* annotated with frequency information (based on the log).
+  * :meth:`pm4py.discovery.discover_performance_dfg`; discovers a *directly follows graph* annotated with performance infomration (based on the log).
+
+Among *procedural process models*, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.discovery.discover_petri_net_alpha`; discovers a *Petri net* using the Alpha Miner algorithm.
+  * :meth:`pm4py.discovery.discover_petri_net_inductive`; discovers a *Petri net* using the Inductive Miner algorithm.
+  * :meth:`pm4py.discovery.discover_petri_net_heuristics`; discovers a *Petri net* using the Heuristics Miner algorithm.
+  * :meth:`pm4py.discovery.discover_petri_net_ilp`; discovers a *Petri net* using the ILP Miner algorithm.
+  * :meth:`pm4py.discovery.discover_process_tree_inductive`; discovers a *process tree* using the Inductive Miner algorithm.
+  * :meth:`pm4py.discovery.discover_bpmn_inductive`; discovers a *BPMN model* using the Inductive Miner algorithm.
+  * :meth:`pm4py.discovery.discover_heuristics_net`; discovers an *heuristics net* using the Heuristics Miner algorithm.
+  * :meth:`pm4py.discovery.discover_footprints`; discovers the *footprints matrix* of the log or the model.
+  * :meth:`pm4py.discovery.discover_powl`; discovers a *partial order workflow language* (POWL) model.
+
+Among *declarative process models*, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.discovery.discover_declare`; discovers a *DECLARE* model.
+  * :meth:`pm4py.discovery.discover_log_skeleton`; discovers a *log skeleton*.
+  * :meth:`pm4py.discovery.discover_temporal_profile`; discovers a *temporal profile*.
+
+
+Conformance Checking (:mod:`pm4py.conformance`)
+-----------------------------------------------
+Conformance checking techniques compare a process model with an event log of the same process. The goal is to check if the event log conforms to the model, and, vice versa.
+Among procedural process models, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.conformance.conformance_diagnostics_token_based_replay`; token-based replay between the event log and a *Petri net*.
+  * :meth:`pm4py.conformance.conformance_diagnostics_alignments`; alignment-based replay between the event log and a *Petri net*.
+  * :meth:`pm4py.conformance.conformance_diagnostics_footprints`; footprints-based conformance diagnostics.
+  * :meth:`pm4py.conformance.fitness_token_based_replay`; evaluation of the fitness between an event log and a *Petri net* using token-based replay.
+  * :meth:`pm4py.conformance.fitness_alignments`; evaluation of the fitness between an event log and a *Petri net* using alignments.
+  * :meth:`pm4py.conformance.fitness_footprints`; evaluation of the fitness based on footprints.
+  * :meth:`pm4py.conformance.precision_token_based_replay`; evaluation of the precision between an event log and a *Petri net* using token-based replay.
+  * :meth:`pm4py.conformance.precision_alignments`; evaluation of the precision between an event log and a *Petri net* using alignments.
+  * :meth:`pm4py.conformance.precision_footprints`; evaluation of the precision based on footprints.
+  * :meth:`pm4py.conformance.replay_prefix_tbr`; replays a prefix (list of activities) on a given *Petri net*, using Token-Based Replay.
+
+Among declarative process models, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.conformance.conformance_log_skeleton`; conformance checking using the *log skeleton*.
+  * :meth:`pm4py.conformance.conformance_declare`; conformance checking using a *DECLARE model*.
+  * :meth:`pm4py.conformance.conformance_temporal_profile`; conformance checking using the *temporal profile*.
+
+
+Visualization (:mod:`pm4py.vis`)
+------------------------------------------
+The ``pm4py`` library implements basic visualizations of process models and statistics.
+Among the on-screen visualizations, ``pm4py`` currently supports:
+
+  * :meth:`pm4py.vis.view_petri_net`; views a *Petri net* model.
+  * :meth:`pm4py.vis.view_dfg`; views a *directly-follows graph* annotated with the frequency.
+  * :meth:`pm4py.vis.view_performance_dfg`; views a *directly-follows graph* annotated with the performance.
+  * :meth:`pm4py.vis.view_process_tree`; views a *process tree*.
+  * :meth:`pm4py.vis.view_bpmn`; views a *BPMN model*.
+  * :meth:`pm4py.vis.view_heuristics_net`; views an *heuristics net*.
+  * :meth:`pm4py.vis.view_dotted_chart`; views a *dotted chart*
+  * :meth:`pm4py.vis.view_sna`; views the results of a *social network analysis*.
+  * :meth:`pm4py.vis.view_case_duration_graph`; views the *case duration graph*.
+  * :meth:`pm4py.vis.view_events_per_time_graph`; views the *events per time graph*.
+  * :meth:`pm4py.vis.view_performance_spectrum`; views the *performance spectrum*.
+  * :meth:`pm4py.vis.view_events_distribution_graph`; views the *events distribution graph*.
+  * :meth:`pm4py.vis.view_ocdfg`; views an *object-centric directly-follows graph*.
+  * :meth:`pm4py.vis.view_ocpn`; views an *object-centric Petri net*.
+  * :meth:`pm4py.vis.view_object_graph`; views an *object-based graph*.
+  * :meth:`pm4py.vis.view_network_analysis`; views the results of a *network analysis*.
+  * :meth:`pm4py.vis.view_transition_system`; views the results of a *transition system*.
+  * :meth:`pm4py.vis.view_prefix_tree`; views a *prefix tree*.
+  * :meth:`pm4py.vis.view_alignments`; views the *alignments table*.
+  * :meth:`pm4py.vis.view_footprints`; views a *footprints table*.
+  * :meth:`pm4py.vis.view_powl`; views a *POWL model*.
+
+We offer also some methods to store the visualizations on the disk:
+
+  * :meth:`pm4py.vis.save_vis_petri_net`; saves the visualization of a *Petri net* model.
+  * :meth:`pm4py.vis.save_vis_dfg`; saves the visualization of a *directly-follows graph* annotated with the frequency.
+  * :meth:`pm4py.vis.save_vis_performance_dfg`; saves the visualization of a *directly-follows graph* annotated with the performance.
+  * :meth:`pm4py.vis.save_vis_process_tree`; saves the visualization of a *process tree*.
+  * :meth:`pm4py.vis.save_vis_bpmn`; saves the visualization of a *BPMN model*.
+  * :meth:`pm4py.vis.save_vis_heuristics_net`; saves the visualization of an *heuristics net*.
+  * :meth:`pm4py.vis.save_vis_dotted_chart`; saves the visualization of a *dotted chart*
+  * :meth:`pm4py.vis.save_vis_sna`; saves the visualization of the results of a *social network analysis*.
+  * :meth:`pm4py.vis.save_vis_case_duration_graph`; saves the visualization of the *case duration graph*.
+  * :meth:`pm4py.vis.save_vis_events_per_time_graph`; saves the visualization of the *events per time graph*.
+  * :meth:`pm4py.vis.save_vis_performance_spectrum`; saves the visualization of the *performance spectrum*.
+  * :meth:`pm4py.vis.save_vis_events_distribution_graph`; saves the visualization of the *events distribution graph*.
+  * :meth:`pm4py.vis.save_vis_ocdfg`; saves the visualization of an *object-centric directly-follows graph*.
+  * :meth:`pm4py.vis.save_vis_ocpn`; saves the visualization of an *object-centric Petri net*.
+  * :meth:`pm4py.vis.save_vis_object_graph`; saves the visualization of an *object-based graph*.
+  * :meth:`pm4py.vis.save_vis_network_analysis`; saves the visualization of the results of a *network analysis*.
+  * :meth:`pm4py.vis.save_vis_transition_system`; saves the visualization of the results of a *transition system*.
+  * :meth:`pm4py.vis.save_vis_prefix_tree`; saves the visualization of a *prefix tree*.
+  * :meth:`pm4py.vis.save_vis_alignments`; saves the visualization of the *alignments table*.
+  * :meth:`pm4py.vis.save_vis_footprints`; saves the visualization of the *footprints table*.
+  * :meth:`pm4py.vis.save_vis_powl`; saves the visualization of a *POWL model*.
+
+
+Statistics (:mod:`pm4py.stats`)
+------------------------------------------
+Different statistics that could be computed on top of event logs are proposed, including:
+
+  * :meth:`pm4py.stats.get_start_activities`; gets the *start activities* from the event log.
+  * :meth:`pm4py.stats.get_end_activities`; gets the *end activities* from the event log.
+  * :meth:`pm4py.stats.get_event_attributes`; gets the *attributes at the event level* of the event log.
+  * :meth:`pm4py.stats.get_trace_attributes`; gets the *attributes at the trace level* of the event log.
+  * :meth:`pm4py.stats.get_event_attribute_values`; gets the values of an *attribute at the event level* of the event log.
+  * :meth:`pm4py.stats.get_trace_attribute_values`; gets the values of an *attribute at the trace level* of the event log.
+  * :meth:`pm4py.stats.get_variants`; gets the *variants* of the event log.
+  * :meth:`pm4py.stats.split_by_process_variant`; splits an event log into sub-dataframes for each process variant.
+  * :meth:`pm4py.stats.get_variants_paths_duration`; method that associates to a log object a Pandas dataframe aggregated by variants and positions (inside the variant).
+  * :meth:`pm4py.stats.get_frequent_trace_segments`; gets the *traces* (segments of activities) of the event log.
+  * :meth:`pm4py.stats.get_case_arrival_average`; gets the *average case arrival rate* from the event log.
+  * :meth:`pm4py.stats.get_cycle_time`; gets the *cycle time* from the event log.
+  * :meth:`pm4py.stats.get_all_case_durations`; gets the list of *case durations* for the cases of the event log.
+  * :meth:`pm4py.stats.get_case_duration`; gets the *case duration* of a specific case in the log.
+  * :meth:`pm4py.stats.get_stochastic_language`; gets the *stochastic language* of an event log or a process model.
+  * :meth:`pm4py.stats.get_service_time`; gets the average *service time* per activity.
+
+
+Filtering (:mod:`pm4py.filtering`)
+------------------------------------------
+Filtering is the restriction of the event log to a subset of the behavior.
+Different methods are offered in pm4py for traditional event logs (.xes, .csv), including:
+
+  * :meth:`pm4py.filtering.filter_start_activities`; filters the *start activities* of the event log.
+  * :meth:`pm4py.filtering.filter_end_activities`; filters the *end activities* of the event log.
+  * :meth:`pm4py.filtering.filter_event_attribute_values`; filters the values of an *attribute at the event level* of the event log.
+  * :meth:`pm4py.filtering.filter_trace_attribute_values`; filters the values of an *attribute at the trace level* of the event log.
+  * :meth:`pm4py.filtering.filter_variants`; filters the *variants* of an event log.
+  * :meth:`pm4py.filtering.filter_directly_follows_relation`; filters the *DF-relations* of an event log.
+  * :meth:`pm4py.filtering.filter_eventually_follows_relation`; filters the *EF-relations* of an event log.
+  * :meth:`pm4py.filtering.filter_time_range`; filters an event log on a temporal interval.
+  * :meth:`pm4py.filtering.filter_between`; filters an event log between a given couple of activities.
+  * :meth:`pm4py.filtering.filter_case_size`; filters an event log on the size of the cases.
+  * :meth:`pm4py.filtering.filter_case_performance`; filters an event log on the throughput time of the cases.
+  * :meth:`pm4py.filtering.filter_activities_rework`; filters an event log by looking at the cases where a given activity is executed different times.
+  * :meth:`pm4py.filtering.filter_paths_performance`; filters an event log by looking at the performance of the paths between two activities.
+  * :meth:`pm4py.filtering.filter_variants_top_k`; filters an event log keeping the top-K variants.
+  * :meth:`pm4py.filtering.filter_variants_by_coverage_percentage`; filters an event log keeping the variants covering the specified percentage of cases.
+  * :meth:`pm4py.filtering.filter_prefixes`; filters the prefixes of an activity.
+  * :meth:`pm4py.filtering.filter_suffixes`; filters the suffixes of an activity.
+  * :meth:`pm4py.filtering.filter_trace_segments`; filters on the given traces (segments of activities).
+  * :meth:`pm4py.filtering.filter_four_eyes_principle`; apply the *Four-Eyes principle* on the event log (LTL).
+  * :meth:`pm4py.filtering.filter_activity_done_different_resources`; filters the cases where an activity is repeated by different resources (LTL).
+
+Also, some filtering techniques are offered on top of object-centric event logs:
+
+  * :meth:`pm4py.filtering.filter_ocel_event_attribute`; filters the events of an object-centric event log having a given value for an attribute.
+  * :meth:`pm4py.filtering.filter_ocel_object_attribute`; filters the objects of an object-centric event log having a given value for an attribute.
+  * :meth:`pm4py.filtering.filter_ocel_object_types_allowed_activities`; filters the relations between events (activities) and objects (object types) in an object-centric event log.
+  * :meth:`pm4py.filtering.filter_ocel_object_per_type_count`; filters the objects of an object-centric event log having at least the specific amount of objects per object type.
+  * :meth:`pm4py.filtering.filter_ocel_start_events_per_object_type`; filters the events of an object-centric event log that start the lifecycle of an object of a given object type.
+  * :meth:`pm4py.filtering.filter_ocel_end_events_per_object_type`; filters the events of an object-centric event log that end the lifecycle of an object of a given object type.
+  * :meth:`pm4py.filtering.filter_ocel_events_timestamp`; filters the events of an object-centric event log based on a timestamp range.
+  * :meth:`pm4py.filtering.filter_ocel_object_types`; filters a specified collection of object types from the object-centric event log.
+  * :meth:`pm4py.filtering.filter_ocel_events`; filters a specified collection of event identifiers from the object-centric event log.
+  * :meth:`pm4py.filtering.filter_ocel_objects`; filters a specified collection of object identifiers from the object-centric event log.
+  * :meth:`pm4py.filtering.filter_ocel_cc_object`; filters a connected component from the object-centric event log to which the object with the provided identifier belongs.
+  * :meth:`pm4py.filtering.filter_ocel_cc_length`; filter the connected components from an object-centric event log having a number of objects falling in a provided range.
+  * :meth:`pm4py.filtering.filter_ocel_cc_otype`; filter the connected components from an object-centric event log having at least an object of the specified object type.
+  * :meth:`pm4py.filtering.filter_ocel_cc_activity`; filter the connected components from an object-centric event log having at least an event with the specified activity.
+
+Machine Learning (:mod:`pm4py.ml`)
+------------------------------------------
+PM4Py offers some features useful for the application of machine learning techniques.
+Among those:
+
+  * :meth:`pm4py.ml.split_train_test`; splits an event log into a *training event log* (default 80% of the cases) and a *test event log* (default 20% of the cases).
+  * :meth:`pm4py.ml.get_prefixes_from_log`; gets fixed-length prefixes for the cases of an event log.
+  * :meth:`pm4py.ml.extract_features_dataframe`; extracts machine learning features from an event log.
+  * :meth:`pm4py.ml.extract_ocel_features`; extracts machine learning features from an object-centric event log.
+  * :meth:`pm4py.ml.extract_temporal_features_dataframe`; extracts temporal features from an event log.
+  * :meth:`pm4py.ml.extract_target_vector`; extracts from a log object the target vector for a specific ML use case.
+  * :meth:`pm4py.ml.extract_outcome_enriched_dataframe`; inserts additional columns in the dataframe which are computed on the overall case, so they model the outcome of the case.
+
+
+Simulation (:mod:`pm4py.sim`)
+------------------------------------------
+We offer different simulation algorithms, that starting from a model, are able to produce an output that follows the model and the different rules that have been provided by the user.
+Among those:
+
+  * :meth:`pm4py.sim.play_out`; performs the play-out of a process model to obtain an event log.
+  * :meth:`pm4py.sim.generate_process_tree`; generates a process tree with the desidered number of nodes.
+
+
+Object-Centric Process Mining (:mod:`pm4py.ocel`)
+--------------------------------------------------
+Traditional event logs, used by mainstream process mining techniques, require the events to be related to a case. A case is a set of events for a particular purpose. A case notion is a criteria to assign a case to the events.
+
+However, in real processes this leads to two problems:
+
+* If we consider the Order-to-Cash process, an order could be related to many different deliveries. If we consider the delivery as case notion, the same event of Create Order needs to be replicated in different cases (all the deliveries involving the order). This is called the convergence problem.
+* If we consider the Order-to-Cash process, an order could contain different order items, each one with a different lifecycle. If we consider the order as case notion, several instances of the activities for the single items may be contained in the case, and this make the frequency/performance annotation of the process problematic. This is called the divergence problem.
+
+Object-centric event logs relax the assumption that an event is related to exactly one case. Indeed, an event can be related to different objects of different object types.
+
+Essentially, we can describe the different components of an object-centric event log as:
+
+* Events, having an identifier, an activity, a timestamp, a list of related objects and a dictionary of other attributes.
+* Objects, having an identifier, a type and a dictionary of other attributes.
+* Attribute names, e.g., the possible keys for the attributes of the event/object attribute map.
+* Object types, e.g., the possible types for the objects.
+
+In PM4Py, we offer object-centric process mining features:
+
+  * :meth:`pm4py.ocel.ocel_get_object_types`; gets the object types from an object-centric event log.
+  * :meth:`pm4py.ocel.ocel_get_attribute_names`; gets the attribute names from an object-centric event log.
+  * :meth:`pm4py.ocel.ocel_flattening`; flattens object-centric event log with the selection of an object type.
+  * :meth:`pm4py.ocel.ocel_object_type_activities`; gets the activities related to an object type in an object-centric event log.
+  * :meth:`pm4py.ocel.ocel_objects_ot_count`; counts the objects for an object type.
+  * :meth:`pm4py.ocel.ocel_temporal_summary`; returns the temporal summary from an object-centric event log.
+  * :meth:`pm4py.ocel.ocel_objects_summary`; returns the objects summary from an object-centric event log.
+  * :meth:`pm4py.ocel.ocel_objects_interactions_summary`; returns the objects interactions from an object-centric event log.
+  * :meth:`pm4py.ocel.sample_ocel_objects`; returns a sampled object-centric event log picking a subset of the objects of the original one.
+  * :meth:`pm4py.ocel.sample_ocel_connected_components`; returns a sampled object-centric event log containing the provided number of connected components.
+  * :meth:`pm4py.ocel.ocel_drop_duplicates`; drops relations between events and objects happening at the same time.
+  * :meth:`pm4py.ocel.ocel_merge_duplicates`; merge events in the OCEL which are happening with the same activity at the same timestamp.
+  * :meth:`pm4py.ocel.ocel_o2o_enrichment`; enriches the O2O table of the OCEL with the grah-based relationships.
+  * :meth:`pm4py.ocel.ocel_e2o_lifecycle_enrichment`; enriches the relations table of the OCEL with lifecycle-based information.
+  * :meth:`pm4py.ocel.cluster_equivalent_ocel`; perform a clustering of the objects of an OCEL based on lifecycle/interactions similarity.
+
+
+Some object-centric process discovery algorithms are also offered:
+
+  * :meth:`pm4py.ocel.discover_ocdfg`; discovers an object-centric directly-follows graph from the object-centric event log.
+  * :meth:`pm4py.ocel.discover_oc_petri_net`; discovers an object-centric Petri net from the object-centric event log.
+  * :meth:`pm4py.ocel.discover_objects_graph`; discovers an object-based graph from the object-centric event log.
+
+
+LLM Integration (:mod:`pm4py.llm`)
+------------------------------------------
+
+The following methods provides just the abstractions of the given objects:
+
+  * :meth:`pm4py.llm.abstract_dfg`; provides the DFG abstraction of a traditional event log
+  * :meth:`pm4py.llm.abstract_variants`; provides the variants abstraction of a traditional event log
+  * :meth:`pm4py.llm.abstract_log_attributes`; provides the abstraction of the attributes/columns of the event log
+  * :meth:`pm4py.llm.abstract_log_features`; provides the abstraction of the machine learning features obtained from an event log
+  * :meth:`pm4py.llm.abstract_case`; provides the abstraction of a case (collection of events)
+  * :meth:`pm4py.llm.abstract_ocel`; provides the abstraction of an object-centric event log (list of events and objects)
+  * :meth:`pm4py.llm.abstract_ocel_ocdfg`; provides the abstraction of an object-centric event log (OC-DFG)
+  * :meth:`pm4py.llm.abstract_ocel_features`; provides the abstraction of an object-centric event log (features for ML)
+  * :meth:`pm4py.llm.abstract_event_stream`; provides an abstraction of the (last) events of the stream related to a traditional event log
+  * :meth:`pm4py.llm.abstract_temporal_profile`; provides the abstraction of a temporal profile model
+  * :meth:`pm4py.llm.abstract_petri_net`; provides the abstraction of a Petri net
+  * :meth:`pm4py.llm.abstract_declare`; provides the abstraction of a DECLARE model
+  * :meth:`pm4py.llm.abstract_log_skeleton`; provides the abstraction of a log skeleton model
+  * :meth:`pm4py.llm.explain_visualization`; explains one of the visualizations provided in pm4py using LVMs.
+
+The following methods can be executed directly against the LLM APIs:
+
+  * :meth:`pm4py.llm.openai_query`; executes a prompt against OpenAI, returning the response as string
+
+
+Basic Connectors (:mod:`pm4py.connectors`)
+------------------------------------------
+
+We offer some basic connectors to get an event log for some processes:
+
+  * :meth:`pm4py.connectors.extract_log_outlook_mails`; extracts a traditional Pandas dataframe representing the Outlook mails
+  * :meth:`pm4py.connectors.extract_log_outlook_calendar`; extracts a traditional Pandas dataframe representing the Outlook calendar
+  * :meth:`pm4py.connectors.extract_log_windows_events`; extracts a traditional Pandas dataframe containing the Windows events registry
+  * :meth:`pm4py.connectors.extract_log_chrome_history`; extracts a traditional Pandas dataframe containing the Chrome navigation history
+  * :meth:`pm4py.connectors.extract_log_firefox_history`; extracts a traditional Pandas dataframe containing the Firefox navigation history
+  * :meth:`pm4py.connectors.extract_log_github`; extracts a traditional Pandas dataframe of a Github repository (issues management)
+  * :meth:`pm4py.connectors.extract_log_camunda_workflow`; extracts a traditional Pandas dataframe from the database supporting Camunda
+  * :meth:`pm4py.connectors.extract_log_sap_o2c`; extracts a traditional Pandas dataframe from the database supporting SAP (O2C process)
+  * :meth:`pm4py.connectors.extract_log_sap_accounting`; extracts a traditional Pandas dataframe from the database supporting SAP (Accounting process)
+  * :meth:`pm4py.connectors.extract_ocel_outlook_mails`; extracts an object-centric event log representing the Outlook mails
+  * :meth:`pm4py.connectors.extract_ocel_outlook_calendar`; extracts an object-centric event log representing the Outlook calendar
+  * :meth:`pm4py.connectors.extract_ocel_windows_events`; extracts an object-centric event log representing the Windows events
+  * :meth:`pm4py.connectors.extract_ocel_chrome_history`; extracts an object-centric event log representing the Chrome history
+  * :meth:`pm4py.connectors.extract_ocel_firefox_history`; extracts an object-centric event log representing the Firefox history
+  * :meth:`pm4py.connectors.extract_ocel_github`; extracts an object-centric event log of a Github repository (issues management)
+  * :meth:`pm4py.connectors.extract_ocel_camunda_workflow`; extracts an object-centric event log from the database supporting Camunda
+  * :meth:`pm4py.connectors.extract_ocel_sap_o2c`; extracts an object-centric event log from the database supporting SAP (O2C process)
+  * :meth:`pm4py.connectors.extract_ocel_sap_accounting`; extracts an object-centric event log from the database supporting SAP (Accounting process)
+
+
+Social Network Analysis (:mod:`pm4py.org`)
+------------------------------------------
+We offer different algorithms for the analysis of the organizational networks starting from an event log:
+
+  * :meth:`pm4py.org.discover_handover_of_work_network`; calculates the Handover of Work metric from the event log.
+  * :meth:`pm4py.org.discover_working_together_network`; calculates the Working Together metric from the event log.
+  * :meth:`pm4py.org.discover_activity_based_resource_similarity`; calculates the activity-based resource similarity.
+  * :meth:`pm4py.org.discover_subcontracting_network`; calculates the Subcontracting metric from the event log.
+  * :meth:`pm4py.org.discover_organizational_roles`; discovers the organizational roles from the event log.
+  * :meth:`pm4py.org.discover_network_analysis`; discovers the network analysis from the event log.
+
+
+Privacy (:mod:`pm4py.privacy`)
+------------------------------------------
+We offer the following algorithms for the anonymization of event logs:
+
+  * :meth:`pm4py.privacy.anonymize_differential_privacy`; PRIPEL (Privacy-preserving event log publishing with contextual information) is a framework to publish event logs that fulfill differential privacy.
+
+
+Utilities (:mod:`pm4py.utils`)
+------------------------------------------
+
+Other algorithms, which do not belong to the aforementioned categories, are collected in this section:
+
+  * :meth:`pm4py.utils.format_dataframe`; ensure the correct formatting of the Pandas dataframe.
+  * :meth:`pm4py.utils.parse_process_tree`; parses a process tree from a string.
+  * :meth:`pm4py.utils.parse_powl_model_string`; parses a POWL model from a string.
+  * :meth:`pm4py.utils.parse_event_log_string`; parses an event log from a collection of comma-separated traces.
+  * :meth:`pm4py.utils.project_on_event_attribute`; projects an event log on top of a given attribute (e.g., the activity), obtaining a list of list of values for the attribute.
+  * :meth:`pm4py.utils.sample_cases`; samples a traditional event log returning the specified amount of cases.
+  * :meth:`pm4py.utils.sample_events`; samples a traditional event log / OCEL returning the specified amount of events.
+  * :meth:`pm4py.utils.serialize`; serializes mainstream pm4py objects as strings.
+  * :meth:`pm4py.utils.deserialize`; de-serializes mainstream pm4py objects given their string representation.
+  * :meth:`pm4py.analysis.cluster_log`; cluster a log into sublogs using the provided clusterer.
+  * :meth:`pm4py.analysis.insert_case_service_waiting_time`; inserts for each case the service and waiting time.
+  * :meth:`pm4py.analysis.insert_case_arrival_finish_rate`; inserts the case arrival/finish rate.
+  * :meth:`pm4py.analysis.insert_artificial_start_end`; inserts artificial start/end activities in the event log.
+  * :meth:`pm4py.analysis.compute_emd`; computes the Earth-Mover Distance between two languages.
+  * :meth:`pm4py.analysis.check_is_workflow_net`; check if a Petri net is a workflow net.
+  * :meth:`pm4py.analysis.check_soundness`; checks if a Petri net is a sound workflow net (Woflan).
+  * :meth:`pm4py.analysis.solve_marking_equation`; solves the marking equation.
+  * :meth:`pm4py.analysis.maximal_decomposition`; performs the maximal decomposition of the given Petri net.
+  * :meth:`pm4py.analysis.generate_marking`; generates a Marking object from a textual representation.
+  * :meth:`pm4py.analysis.reduce_petri_net_invisibles`; reduces the invisible transitions of a Petri net when possible.
+  * :meth:`pm4py.analysis.reduce_petri_net_implicit_places`; reduces the implicit places in the Petri net (MURATA).
+  * :meth:`pm4py.analysis.get_enabled_transitions`; gets the transitions enabled in a given marking.
+
+
+Overall List of Methods
+------------------------------------------
+
+.. autosummary::
+   :toctree: generated
+
+   pm4py.read
+   pm4py.read.read_bpmn
+   pm4py.read.read_dfg
+   pm4py.read.read_pnml
+   pm4py.read.read_ptml
+   pm4py.read.read_xes
+   pm4py.read.read_ocel_csv
+   pm4py.read.read_ocel_jsonocel
+   pm4py.read.read_ocel_xmlocel
+   pm4py.read.read_ocel_sqlite
+   pm4py.read.read_ocel2_xml
+   pm4py.read.read_ocel2_sqlite
+   pm4py.read.read_ocel2_json
+   pm4py.write
+   pm4py.write.write_bpmn
+   pm4py.write.write_dfg
+   pm4py.write.write_pnml
+   pm4py.write.write_ptml
+   pm4py.write.write_xes
+   pm4py.write.write_ocel_csv
+   pm4py.write.write_ocel_jsonocel
+   pm4py.write.write_ocel_xmlocel
+   pm4py.write.write_ocel_sqlite
+   pm4py.write.write_ocel2_xml
+   pm4py.write.write_ocel2_sqlite
+   pm4py.write.write_ocel2_json
+   pm4py.convert
+   pm4py.convert.convert_to_event_log
+   pm4py.convert.convert_to_event_stream
+   pm4py.convert.convert_to_dataframe
+   pm4py.convert.convert_to_bpmn
+   pm4py.convert.convert_to_petri_net
+   pm4py.convert.convert_to_process_tree
+   pm4py.convert.convert_to_reachability_graph
+   pm4py.convert.convert_log_to_ocel
+   pm4py.convert.convert_log_to_networkx
+   pm4py.convert.convert_ocel_to_networkx
+   pm4py.convert.convert_petri_net_to_networkx
+   pm4py.convert.convert_petri_net_type
+   pm4py.discovery
+   pm4py.discovery.discover_dfg
+   pm4py.discovery.discover_performance_dfg
+   pm4py.discovery.discover_petri_net_alpha
+   pm4py.discovery.discover_petri_net_inductive
+   pm4py.discovery.discover_petri_net_heuristics
+   pm4py.discovery.discover_petri_net_ilp
+   pm4py.discovery.discover_process_tree_inductive
+   pm4py.discovery.discover_heuristics_net
+   pm4py.discovery.derive_minimum_self_distance
+   pm4py.discovery.discover_footprints
+   pm4py.discovery.discover_eventually_follows_graph
+   pm4py.discovery.discover_bpmn_inductive
+   pm4py.discovery.discover_transition_system
+   pm4py.discovery.discover_prefix_tree
+   pm4py.discovery.discover_temporal_profile
+   pm4py.discovery.discover_declare
+   pm4py.discovery.discover_log_skeleton
+   pm4py.discovery.discover_batches
+   pm4py.discovery.discover_powl
+   pm4py.conformance
+   pm4py.conformance.conformance_diagnostics_token_based_replay
+   pm4py.conformance.conformance_diagnostics_alignments
+   pm4py.conformance.conformance_diagnostics_footprints
+   pm4py.conformance.fitness_token_based_replay
+   pm4py.conformance.fitness_alignments
+   pm4py.conformance.fitness_footprints
+   pm4py.conformance.precision_token_based_replay
+   pm4py.conformance.precision_alignments
+   pm4py.conformance.precision_footprints
+   pm4py.conformance.replay_prefix_tbr
+   pm4py.conformance.conformance_temporal_profile
+   pm4py.conformance.conformance_declare
+   pm4py.conformance.conformance_log_skeleton
+   pm4py.vis
+   pm4py.vis.view_petri_net
+   pm4py.vis.save_vis_petri_net
+   pm4py.vis.view_performance_dfg
+   pm4py.vis.save_vis_performance_dfg
+   pm4py.vis.view_dfg
+   pm4py.vis.save_vis_dfg
+   pm4py.vis.view_process_tree
+   pm4py.vis.save_vis_process_tree
+   pm4py.vis.view_bpmn
+   pm4py.vis.save_vis_bpmn
+   pm4py.vis.view_heuristics_net
+   pm4py.vis.save_vis_heuristics_net
+   pm4py.vis.view_dotted_chart
+   pm4py.vis.save_vis_dotted_chart
+   pm4py.vis.view_sna
+   pm4py.vis.save_vis_sna
+   pm4py.vis.view_case_duration_graph
+   pm4py.vis.save_vis_case_duration_graph
+   pm4py.vis.view_events_per_time_graph
+   pm4py.vis.save_vis_events_per_time_graph
+   pm4py.vis.view_performance_spectrum
+   pm4py.vis.save_vis_performance_spectrum
+   pm4py.vis.view_events_distribution_graph
+   pm4py.vis.save_vis_events_distribution_graph
+   pm4py.vis.view_ocdfg
+   pm4py.vis.save_vis_ocdfg
+   pm4py.vis.view_ocpn
+   pm4py.vis.save_vis_ocpn
+   pm4py.vis.view_object_graph
+   pm4py.vis.save_vis_object_graph
+   pm4py.vis.view_network_analysis
+   pm4py.vis.save_vis_network_analysis
+   pm4py.vis.view_transition_system
+   pm4py.vis.save_vis_transition_system
+   pm4py.vis.view_prefix_tree
+   pm4py.vis.save_vis_prefix_tree
+   pm4py.vis.view_alignments
+   pm4py.vis.save_vis_alignments
+   pm4py.vis.view_footprints
+   pm4py.vis.save_vis_footprints
+   pm4py.vis.view_powl
+   pm4py.vis.save_vis_powl
+   pm4py.stats
+   pm4py.stats.get_start_activities
+   pm4py.stats.get_end_activities
+   pm4py.stats.get_event_attributes
+   pm4py.stats.get_trace_attributes
+   pm4py.stats.get_event_attribute_values
+   pm4py.stats.get_trace_attribute_values
+   pm4py.stats.get_variants
+   pm4py.stats.get_variants_as_tuples
+   pm4py.stats.split_by_process_variant
+   pm4py.stats.get_variants_paths_duration
+   pm4py.stats.get_minimum_self_distances
+   pm4py.stats.get_minimum_self_distance_witnesses
+   pm4py.stats.get_case_arrival_average
+   pm4py.stats.get_rework_cases_per_activity
+   pm4py.stats.get_cycle_time
+   pm4py.stats.get_all_case_durations
+   pm4py.stats.get_case_duration
+   pm4py.stats.get_frequent_trace_segments
+   pm4py.stats.get_service_time
+   pm4py.stats.get_activity_position_summary
+   pm4py.stats.get_stochastic_language
+   pm4py.filtering
+   pm4py.filtering.filter_log_relative_occurrence_event_attribute
+   pm4py.filtering.filter_start_activities
+   pm4py.filtering.filter_end_activities
+   pm4py.filtering.filter_event_attribute_values
+   pm4py.filtering.filter_trace_attribute_values
+   pm4py.filtering.filter_variants
+   pm4py.filtering.filter_directly_follows_relation
+   pm4py.filtering.filter_eventually_follows_relation
+   pm4py.filtering.filter_time_range
+   pm4py.filtering.filter_between
+   pm4py.filtering.filter_case_size
+   pm4py.filtering.filter_case_performance
+   pm4py.filtering.filter_activities_rework
+   pm4py.filtering.filter_paths_performance
+   pm4py.filtering.filter_variants_top_k
+   pm4py.filtering.filter_variants_by_coverage_percentage
+   pm4py.filtering.filter_prefixes
+   pm4py.filtering.filter_suffixes
+   pm4py.filtering.filter_trace_segments
+   pm4py.filtering.filter_ocel_event_attribute
+   pm4py.filtering.filter_ocel_object_attribute
+   pm4py.filtering.filter_ocel_object_types_allowed_activities
+   pm4py.filtering.filter_ocel_object_per_type_count
+   pm4py.filtering.filter_ocel_start_events_per_object_type
+   pm4py.filtering.filter_ocel_end_events_per_object_type
+   pm4py.filtering.filter_ocel_events_timestamp
+   pm4py.filtering.filter_four_eyes_principle
+   pm4py.filtering.filter_activity_done_different_resources
+   pm4py.filtering.filter_ocel_object_types
+   pm4py.filtering.filter_ocel_events
+   pm4py.filtering.filter_ocel_objects
+   pm4py.filtering.filter_ocel_cc_object
+   pm4py.filtering.filter_ocel_cc_length
+   pm4py.filtering.filter_ocel_cc_otype
+   pm4py.filtering.filter_ocel_cc_activity
+   pm4py.ml
+   pm4py.ml.split_train_test
+   pm4py.ml.get_prefixes_from_log
+   pm4py.ml.extract_features_dataframe
+   pm4py.ml.extract_temporal_features_dataframe
+   pm4py.ml.extract_target_vector
+   pm4py.ml.extract_outcome_enriched_dataframe
+   pm4py.ml.extract_ocel_features
+   pm4py.sim
+   pm4py.sim.play_out
+   pm4py.sim.generate_process_tree
+   pm4py.ocel
+   pm4py.ocel.ocel_get_object_types
+   pm4py.ocel.ocel_get_attribute_names
+   pm4py.ocel.ocel_flattening
+   pm4py.ocel.ocel_object_type_activities
+   pm4py.ocel.ocel_objects_ot_count
+   pm4py.ocel.discover_ocdfg
+   pm4py.ocel.discover_oc_petri_net
+   pm4py.ocel.ocel_temporal_summary
+   pm4py.ocel.ocel_objects_summary
+   pm4py.ocel.ocel_objects_interactions_summary
+   pm4py.ocel.sample_ocel_objects
+   pm4py.ocel.sample_ocel_connected_components
+   pm4py.ocel.ocel_drop_duplicates
+   pm4py.ocel.ocel_merge_duplicates
+   pm4py.ocel.ocel_o2o_enrichment
+   pm4py.ocel.ocel_e2o_lifecycle_enrichment
+   pm4py.ocel.cluster_equivalent_ocel
+   pm4py.llm
+   pm4py.llm.abstract_dfg
+   pm4py.llm.abstract_variants
+   pm4py.llm.abstract_ocel
+   pm4py.llm.abstract_ocel_ocdfg
+   pm4py.llm.abstract_ocel_features
+   pm4py.llm.abstract_event_stream
+   pm4py.llm.abstract_petri_net
+   pm4py.llm.abstract_log_attributes
+   pm4py.llm.abstract_log_features
+   pm4py.llm.abstract_temporal_profile
+   pm4py.llm.abstract_case
+   pm4py.llm.abstract_declare
+   pm4py.llm.abstract_log_skeleton
+   pm4py.llm.openai_query
+   pm4py.llm.explain_visualization
+   pm4py.connectors.extract_log_outlook_mails
+   pm4py.connectors.extract_log_outlook_calendar
+   pm4py.connectors.extract_log_windows_events
+   pm4py.connectors.extract_log_chrome_history
+   pm4py.connectors.extract_log_firefox_history
+   pm4py.connectors.extract_log_github
+   pm4py.connectors.extract_log_camunda_workflow
+   pm4py.connectors.extract_log_sap_o2c
+   pm4py.connectors.extract_log_sap_accounting
+   pm4py.connectors.extract_ocel_outlook_mails
+   pm4py.connectors.extract_ocel_outlook_calendar
+   pm4py.connectors.extract_ocel_windows_events
+   pm4py.connectors.extract_ocel_chrome_history
+   pm4py.connectors.extract_ocel_firefox_history
+   pm4py.connectors.extract_ocel_github
+   pm4py.connectors.extract_ocel_camunda_workflow
+   pm4py.connectors.extract_ocel_sap_o2c
+   pm4py.connectors.extract_ocel_sap_accounting
+   pm4py.org
+   pm4py.org.discover_handover_of_work_network
+   pm4py.org.discover_working_together_network
+   pm4py.org.discover_activity_based_resource_similarity
+   pm4py.org.discover_subcontracting_network
+   pm4py.org.discover_organizational_roles
+   pm4py.org.discover_network_analysis
+   pm4py.analysis
+   pm4py.analysis.cluster_log
+   pm4py.analysis.insert_case_service_waiting_time
+   pm4py.analysis.insert_case_arrival_finish_rate
+   pm4py.analysis.solve_marking_equation
+   pm4py.analysis.check_soundness
+   pm4py.analysis.insert_artificial_start_end
+   pm4py.analysis.check_is_workflow_net
+   pm4py.analysis.maximal_decomposition
+   pm4py.analysis.generate_marking
+   pm4py.analysis.compute_emd
+   pm4py.analysis.reduce_petri_net_invisibles
+   pm4py.analysis.reduce_petri_net_implicit_places
+   pm4py.analysis.get_enabled_transitions
+   pm4py.utils
+   pm4py.utils.rebase
+   pm4py.utils.parse_process_tree
+   pm4py.utils.parse_powl_model_string
+   pm4py.utils.format_dataframe
+   pm4py.utils.serialize
+   pm4py.utils.deserialize
+   pm4py.utils.parse_event_log_string
+   pm4py.utils.project_on_event_attribute
+   pm4py.utils.sample_cases
+   pm4py.utils.sample_events

pm4py/docs/source/conf.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+#
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath('../../'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'pm4py'
+project_copyright = 'Process Intelligence Solutions'
+author = 'Process Intelligence Solutions'
+
+# The short X.Y version
+version = '2.7'
+# The full version, including alpha/beta/rc tags
+release = '2.7.10'
+
+# -- General configuration ---------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx_autodoc_annotation',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.autosummary',
+]
+
+autodoc_mock_imports = ["cvxopt"]
+napoleon_google_docstring = False
+napoleon_use_param = False
+napoleon_use_ivar = True
+autodoc_member_order = 'bysource'
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these traces.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path .
+exclude_patterns = ['tests', 'scripts']
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'pydata_sphinx_theme'
+html_logo = 'pm4py-logo.png'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+html_theme_options = {
+   "logo": {
+      "image_light": "pm4py-logo.png",
+      "image_dark": "pm4py-logo.png",
+   },
+    "navbar_persistent": []
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+html_css_files = ["css/custom.css"]
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# The default sidebars (for documents that don't match any pattern) are
+# defined by theme itself.  Builtin themes are using these templates by
+# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
+# 'searchbox.html']``.
+#
+# html_sidebars = {}
+
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'pm4pydoc'
+
+# -- Options for LaTeX output ------------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'pm4py.tex', 'pm4py API reference',
+     'pm4py @ Process Intelligence Solutions', 'manual'),
+]
+
+# -- Options for manual page output ------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'pm4py', 'pm4py API reference',
+     [author], 1)
+]
+
+# -- Options for Texinfo output ----------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'pm4py', 'pm4py API reference',
+     author, 'pm4py', 'Process Mining for Python API reference.',
+     'Miscellaneous'),
+]
+
+# -- Extension configuration -------------------------------------------------

pm4py/docs/source/examples.rst

@@ -0,0 +1,11 @@
+Examples
+============
+
+Filtering XYZ
+-------------
+
+Decision Point Analysis
+-----------------------
+
+Computing a DFG with Performance Overlay
+----------------------------------------

pm4py/docs/source/getting_started.rst

@@ -0,0 +1,410 @@
+Getting Started
+===============
+
+Understanding Process Mining
+----------------------------
+
+.. raw:: html
+
+    <!--<iframe width="560" height="315" src="https://www.youtube.com/embed/XLHtvt36g6U" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/XLHtvt36g6U" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #1 What is Process Mining?</a>
+
+
+In this section, we explain what process mining is all about. 
+Note that this page describes the basics of process mining, i.e., it is not a full-fledged reference of every possible aspect of process mining. 
+Therefore, for a more detailed overview of process mining, we recommend looking at the `Coursera MOOC on Process Mining <https://www.coursera.org/learn/process-mining>`_ and the `seminal book of Wil van der Aalst <https://www.springer.com/gp/book/9783662498507>`_. 
+Furthermore, before you begin, please install PM4Py on your system, i.e., as described in the :doc:`install` section.
+
+Processes in our Modern World
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The vast majority of companies active in virtually any domain execute a process. 
+Whether the core business of a company is to deliver a product, e.g., manufacture a car, cook a delicious pizza, etc., or provide a service, e.g., providing you with a mortgage to buy your dream house, paying back your insurance claim, etc., for efficient delivery of your product/service, processes are executed. 
+Hence, a natural question is: “What is a process?”. 
+In general, several notions of the concept of a process exist. 
+However, in process mining, we typically assume the following conceptual definition:
+
+"A **process** represents a **collection of activities** that we **execute** to achieve a **certain goal**."
+
+For example, consider the burger restaurant just around the corner, which also delivers burgers.
+When you call the restaurant to order your beloved burger, the first action taken by the employee, let’s call her **Lucy**, taking your call, is to *take your order*. 
+Let’s assume you go for a tasty cheeseburger with a can of soda. 
+After Lucy has *entered your order in the cash register*, she *asks for your address*, which she adds to the order. 
+Finally, she *asks for your preferred means of payment*, after which she provides you with a rough estimate of the time until delivery. 
+When Lucy finishes the call, she *prints your order* and hands it over to the chef, let’s call him **Luigi**. 
+Since you’ve called relatively early, Luigi can start *preparing your burger* right away. 
+At the same time, Lucy *takes a can of soda out of the refrigerator* and places it on the counter. 
+A new call comes in from a different customer, which she handles roughly the same way as yours. 
+When Luigi *finishes your burger*, he *slides it into a carton box* and hands the box over to Lucy. 
+Lucy *wraps the order* in a bag. 
+She then hands the bag with your burger and soda to **Mike**, which uses a fancy electrical bicycle to *bring your order to your home*.
+
+In this small example, let’s assume that we are interested in the process, i.e., the collection of activities performed for your order. 
+Based on the scenario we just presented, the steps look as follows:
+
+
+1. **Lucy** *takes your order*
+#. **Lucy** *notes down your address*
+#. **Lucy** *notes down your preferred payment method*
+#. **Luigi** *prepares your burger*
+#. **Lucy** *grabs your can of soda*
+#. **Luigi** *puts your burger in a box*
+#. **Lucy** *wraps your order*
+#. **Mike** *delivers your order*
+
+Importing Your First Event Log
+------------------------------
+In this section, we explain how to import (and export) event data in PM4Py. We assume that you are familiar with the conceptual basics of process mining, i.e., as described in the previous section.
+
+File Types: CSV and XES
+~~~~~~~~~~~~~~~~~~~~~~~~
+As explained in the previous section, process mining exploits Event Logs to generate knowledge of a process. A wide variety of information systems, e.g., SAP, ORACLE, SalesForce, etc., allow us to extract, in one way or the other, event logs similar to the example event log presented in Table 1 and Table 2. All the examples we show in this section and all algorithms implemented in pm4py assume that we have already extracted the event data into an appropriate event log format. Hence, the core of pm4py does not support any data extraction features. However, we provide solutions for data extraction purposes, i.e., please inspect the corresponding `solutions page </solution-connectors>`_.
+
+In order to support interoperability between different process mining tools and libraries, two standard data formats are used to capture event logs, i.e., Comma Separated Value (CSV) files and eXtensible Event Stream (XES) files. CSV files resemble the example tables shown in the previous section, i.e., Table 1 and Table 2. Each line in such a file describes an event that occurred. The columns represent the same type of data, as shown in the examples, e.g., the case for which the event occurred, the activity, the timestamp, the resource executing the activity, etc. The XES file format is an XML-based format that allows us to describe process behavior. We will not go into details w.r.t. the format of XES files, i.e., we refer to `https://www.xes-standard.org <https://www.xes-standard.org>`_ for an overview.
+
+In the remainder of this tutorial, we will use an oftenly used dummy example event log to explain the basic process mining operations. The process that we are considering is a simplified process related to customer complaint handling, i.e., *taken from the book of van der Aalst*. The process, and the event data we are going to use, looks as follows.
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/bpmn_running_example.png
+
+*Figure 3: Running example BPMN-based process model describing the behavior of the simple process that we use in this tutorial.*
+
+Let’s get started! We have prepared a small sample event log, containing behavior similar equal to the process model in Figure 3. `You can find the sample event log here </static/assets/data/getting_started/running-example.csv>`_. Please download the file and store it somewhere on your computer, e.g., your Downloads folder (On Windows: this is 'C:/Users/user_name/Dowloads'). Consider Figure 4, in which we depict the first 25 rows of the example file.
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/csv_snapshot.png
+
+*Figure 4: Running example csv data set which we will use in this tutorial.*
+
+Note that, the data depicted in Figure 4 describes a table, however, in text format. Each line in the file corresponds to a row in the table. Whenever we encounter a ‘;’ symbol on a line, this implies that we are ‘entering’ the next column. The first line (i.e., row) specifies the name of each column. Observe that, in the data table described by the file, we have 5 columns, being: *case_id*, *activity*, *timestamp*, *costs* and *resource*. Observe that, similar to our previous example, the first column represents the case identifier, i.e., allowing us to identify what activity has been logged in the context of what instance of the process. The second column shows the activity that has been performed. The third column shows at what point in time the activity was recorded. In this example data, additional information is present as well. In this case, the fourth column tracks the costs of the activity, whereas the fifth row tracks what resource has performed the activity.
+
+Before we go into loading the example file into PM4Py, let us briefly take a look at the data. Observe that, lines 2-10 show the events that have been recorded for the process identified by case identifier 3. We observe that first a register request activity was performed, followed by the examine casually, check ticket, decide,reinitiate request, examine thoroughlycheck ticket,decide, and finally, pay compensation activities. Note that, indeed, in this case the recorded process instance behaves as described by the model depicted in Figure 3.
+
+Loading CSV Files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: html
+
+	<!--<iframe width="560" height="315" src="https://www.youtube.com/embed/bWOKVx0PO6g" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/bWOKVx0PO6g" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #2 Importing CSV Files</a>
+
+
+Given that we have familiarized ourselves with event logs and a way to represent event logs in a CSV file, it is time to start doing some process mining! We are going to load the event data, and, we are going to count how many cases are present in the event log, as well as the number of events. Note that, for all this, we are effectively using a third-party library called `pandas <https://pandas.pydata.org>`_. We do so because pandas is the de-facto standard of loading/manipulating csv-based data. Hence, *any process mining algorithm implemented in PM4Py, using an event log as an input, can work directly with a pandas file!*
+
+.. code-block:: python3
+
+    import pandas
+
+
+    def import_csv(file_path):
+        event_log = pandas.read_csv(file_path, sep=';')
+        num_events = len(event_log)
+        num_cases = len(event_log.case_id.unique())
+        print("Number of events: {}\nNumber of cases: {}".format(num_events, num_cases))
+
+
+    if __name__ == "__main__":
+        import_csv("C:/Users/demo/Downloads/running-example.csv")
+
+*Example 1: Loading an event log stored in a CSV file and computing the number of cases and the number of events in the file. In this example, no PM4Py is used yet, it is all being handled using pandas. If you run the code yourself, make sure to replace the path 'C:/Users/demo/Downloads/running-example.csv', to the appropriate path on your computer containing the running example file.*
+
+We will quickly go through the above example code. In the first line, we import the pandas library. The last lines (containing the if-statement) make sure that the code, when pasted, runs on its own (we will omit these lines from future examples). The core of the script is the function **import_csv**. As an input parameter, it requires the path to the csv file. The script uses the pandas read_csv-function, to load the event data. To calculate the number of events, we simply query the length of the data frame, i.e., by calling **len(event_log)**. To calculate the number of cases, we use a built-in pandas function to return the number of unique values of the case_id column, i.e., **event_log.case_id.unique()**. Since that function returns a pandas built-in array object containing all the values of the column, we again query for its length. Note that, as is often the case when programming, there is a wide variety of ways to compute the aforementioned example statistics on the basis of a given CSV file.
+
+Now we have loaded our first event log, it is time to put some PM4Py into the mix. Let us assume that we are not only interested in the number of events and cases, yet, we also want to figure out what activities occur first, and what activities occur last in the traces described by the event log. PM4Py has a specific built-in function for this, i.e., **get_start_activities()** and **get_end_activities()** respectively. Consider Example 2, in which we present the corresponding script.
+
+.. code-block:: python3
+
+    import pandas
+    import pm4py
+
+
+    def import_csv(file_path):
+        event_log = pandas.read_csv(file_path, sep=';')
+        event_log = pm4py.format_dataframe(event_log, case_id='case_id', activity_key='activity', timestamp_key='timestamp')
+        start_activities = pm4py.get_start_activities(event_log)
+        end_activities = pm4py.get_end_activities(event_log)
+        print("Start activities: {}\nEnd activities: {}".format(start_activities, end_activities))
+
+    if __name__ == "__main__":
+        import_csv("csv_file.csv")
+
+*Example 2: Loading an event log stored in a CSV file and computing the start and end activities of the traces in the event log. If you run the code yourself, make sure to point the file path to the appropriate path on your computer containing the running example file.*
+
+Note that, we now import pandas and pm4py. The first line of our script again loads the event log stored in CSV format as a data frame. The second line transforms the event data table into a format that can be used by any process mining algorithm in pm4py. That is, the **format_dataframe()**-function creates a copy of the input event log, and renames the assigned columns to standardized column names used in pm4py. In our example, the column case_id is renamed to case:concept:name, the activity column is renamed to concept:name and the timestamp column is renamed to time:timestamp. The underlying reasons for using the aforementioned standard names is primarily related to XES-based (the other file format that we will look at shortly) legacy. Hence, it is advisable to always import a csv based log as follows.
+
+Note that, in this example, the value of the arguments, i.e., *sep*, *case_id*, *activity_key* and *timestamp_key* are depending on the input data. To obtain the activities that occur first and, respectively, last in any trace in the event log, we call the pm4py.get_start_activities(event_log) and the pm4py.get_end_activities(event_log) functions. The functions return a dictionary, containing the activities as a key, and, the number of observations (i.e., number of traces in which they occur first, respectively, last) in the event log.
+
+PM4Py exploits a built-in pandas function to detect the format of the timestamps in the input data automatically. However, pandas looks at the timestamp values in each row in isolation. In some cases, this can lead to problems. For example, if the provided value is 2020-01-18, i.e., first the year, then the month, and then the day of the date, in some cases, a value of 2020-02-01 may be interpreted wrongly as January 2nd, i.e., rather than February 1st. To alleviate this problem, an additional parameter can be provided to the **format_dataframe()** method, i.e., the timest_format parameter. In this example, the timestamp format is %Y-%m-%d %H:%M:%S%z. In general, we advise to specify the timestamp format!
+
+Loading XES Files
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: html
+
+	<!--<iframe width="560" height="315" src="https://www.youtube.com/embed/pmpN3A_h2sQ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/pmpN3A_h2sQ" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #3 Importing XES Files</a>
+
+Next to CSV files, event data can also be stored in an XML-based format, i.e., in XES files. In an XES file, we can describe a containment relation, i.e., a log contains a number of traces, which in turn contain several events. Furthermore, an object, i.e., a log, trace, or event, is allowed to have attributes. The advantage is that certain data attributes that are constant for a log or a trace, can be stored at that level. For example, assume that we only know the total costs of a case, rather than the costs of the individual events. If we want to store this information in a CSV file, we either need to replicate this information (i.e., we can only store data in rows, which directly refer to events), or, we need to explicitly define that certain columns only get a value once, i.e., referring to case-level attributes. The XES standard more naturally supports the storage of this type of information.
+
+Consider Figure 5, in which we depict a snapshot of the running example data stored in the .xes file format. The complete file can be downloaded
+`here <https://pm4py.fit.fraunhofer.de/static/assets/data/getting_started/running-example.xes>`_.
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/csv_snapshot.png
+
+*Figure 5: Running example xes data set.*
+
+Observe that the trace with number 1 (reflected by the [string key=”concept:name”]-tag on line 9) is the first trace recorded in this event log. The first event of the trace represents the “register request” activity executed by Pete. The second event is the “examine thoroughly” activity, executed by Sue, etc. We will not elaborate on the XES standard in detail here, i.e., we refer to the `XES homepage <http://www.xes-standard.org/>`_, and, to our `video tutorial <https://www.youtube.com/watch?v=pmpN3A_h2sQ&t=1785s&ab_channel=ProcessMiningforPython>`_ on importing XES for more information.
+
+Importing an XES file is fairly straightforward. PM4Py has a special **read_xes()**-function that can parse a given xes file and load it in PM4Py, i.e., as an Event Log object. Consider the following code snippet, in which we show how to import an XES event log. Like the previous example, the script outputs activities that can start and end a trace.
+
+.. code-block:: python3
+
+    def import_xes(file_path):
+        event_log = pm4py.read_xes(file_path)
+        start_activities = pm4py.get_start_activities(event_log)
+        end_activities = pm4py.get_end_activities(event_log)
+        print("Start activities: {}\nEnd activities: {}".format(start_activities, end_activities))
+
+    if __name__ == "__main__":
+        import_xes("C:/Users/demo/Downloads/running-example.xes")
+
+Exporting Event Data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: html
+
+	<!--<iframe width="560" height="315" src="https://www.youtube.com/embed/gVnfG6xLIxI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/gVnfG6xLIxI" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #6 exporting event data</a>
+
+
+Now we are able to import event data into PM4Py, let’s take a look at the opposite, i.e., exporting event data. Exporting of event logs can be very useful, e.g., we might want to convert a .csv file into a .xes file or we might want to filter out certain (noisy) cases and save the filtered event log. Like importing, exporting of event data is possible in two ways, i.e., exporting to csv (using pandas) and exporting to xes. In the upcoming sections, we show how to export an event log stored as a pandas data frame into a csv file, a pandas data frame as a xes file, a PM4Py event log object as a csv file and finally, a PM4Py event log object as a xes file.
+
+Storing a Pandas Data Frame as a csv file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Storing an event log that is represented as a pandas dataframe is straightforward, i.e., we can directly use the **to_csv** function of the pandas DataFrame object. Consider the following example snippet of code, in which we show this functionality.
+
+Note that the example code imports the running example csv file as a pandas data frame, and, exports it to a csv file at the location ‘C:/Users/demo/Desktop/running-example-exported.csv’. Note that, by default, pandas uses a ‘,’-symbol rather than ‘;’-symbol as a column separator.
+
+.. code-block:: python3
+
+    import pandas as pd
+
+    if __name__ == "__main__":
+        event_log = pm4py.format_dataframe(pd.read_csv('C:/Users/demo/Downloads/running-example.csv', sep=';'), case_id='case_id',
+        activity_key='activity', timestamp_key='timestamp')
+        event_log.to_csv('C:/Users/demo/Desktop/running-example-exported.csv')
+
+Storing a Pandas Data Frame as a .xes file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+It is also possible to store a pandas data frame to a xes file. This is simply done by calling the **pm4py.write_xes()** function. You can pass the dataframe as an input parameter to the function, i.e., pm4py handles the internal conversion of the dataframe to an event log object prior to writing it to disk. Note that this construct only works if you have formatted the data frame, i.e., as highlighted earlier in the importing CSV section.
+
+.. code-block:: python3
+
+    import pandas
+    import pm4py
+
+    if __name__ == "__main__":
+        event_log = pm4py.format_dataframe(pandas.read_csv('C:/Users/demo/Downloads/running-example.csv', sep=';'), case_id='case_id',
+                                               activity_key='activity', timestamp_key='timestamp')
+        pm4py.write_xes(event_log, 'C:/Users/demo/Desktop/running-example-exported.xes')
+
+Storing an Event Log object as a .csv file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In some cases, we might want to store an event log object, e.g., obtained by importing a .xes file, as a csv file. For example, certain (commercial) process mining tools only support csv importing. For this purpose, pm4py offers conversion functionality that allows you to convert your event log object into a data frame, which you can subsequently export using pandas.
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        event_log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+        df = pm4py.convert_to_dataframe(event_log)
+        df.to_csv('C:/Users/demo/Desktop/running-example-exported.csv')
+
+Storing an Event Log object as a .xes file
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Storing an event log object as a .xes file is rather straightforward. In pm4py, the **write_xes()** method allows us to do so. Consider the simple example script below in which we show an example of this functionality.
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        event_log = pm4py.read_xes(C:/Users/demo/Downloads/running-example.xes)
+        pm4py.write_xes(event_log, 'C:/Users/demo/Desktop/running-example-exported.xes')
+
+Pre-Built Event Log Filters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. raw:: html
+
+	<!--<iframe width="560" height="315" src="https://www.youtube.com/embed/alkZkhK2mAo" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/alkZkhK2mAo" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #5: Playing with Event Data; Shipped Filters</a>
+
+There are various pre-built filters in PM4Py, which make commonly needed process mining filtering functionality a lot easier. In the upcoming list, we briefly give an overview of these functions. We describe how to call them, their main input parameters and their return objects.
+
+* **filter_start_activities(log, activities, retain=True)**; This function filters the given event log object (either a data frame or a PM4Py event log object) based on a given set of input activity names that need to occur at the starting point of a trace. If we set retain to False, we remove all traces that contain any of the specified activities as their first event.
+* **filter_end_activities(log, activities, retain=True)**; Similar functionality to the start activity filter. However, in this case, the filter is applied for the activities that occur at the end of a trace.
+* **filter_event_attribute_values(log, attribute_key, values, level="case", retain=True)**; Filters an event log (either data frame or PM4Py EventLog object) on event attributes. The attribute_key is a string representing the attribute key to filter, the values parameter allows you to specify a set of allowed values. If the level parameter is set to 'case', then any trace that contains at least one event that matches the attribute-value combination is retained. If the level parameter value is set to 'event', only the events are retained that describe the specified value. Setting retain to False inverts the filter.
+* **filter_trace_attribute_values(log, attribute_key, values, retain=True)**; Keeps (or removes if retain is set to False) only the traces that have an attribute value for the provided attribute_key and listed in the collection of corresponding values.
+* **filter_variants(log, variants, retain=True)**; Keeps those traces that correspond to a specific activity execution sequence, i.e., known as a variant. For example, in a large log, we want to retain all traces that describe the execution sequence 'a', 'b', 'c'. The variants parameter is a collection of lists of activity names.
+* **filter_directly_follows_relation(log, relations, retain=True)**; This function filters all traces that contain a specified 'directly follows relation'. Such a relation is simply a pair of activities, e.g., ('a','b') s.t., 'a' is directly followed by 'b' in a trace. For example, the trace <'a','b','c','d'> contains directly follows pairs ('a','b'), ('b','c') and ('c','d'). The relations parameter is a set of tuples, containing activity names. The retain parameter allows us to express whether or not we want to keep or remove the mathcing traces.
+* **filter_eventually_follows_relation(log, relations, retain=True)** This function allows us to match traces on a generalization of the directly follows relation, i.e., an arbitrary number of activities is allowed to occur in-between the input relations. For example, when we call the function with a relation ('a','b'), any trace in which we observe activity 'a' at some point, to be followed later by activity 'b', again at some point, adheres to this filter. For example, a trace <'a','b','c','d'> contains eventually follows pairs ('a','b'), ('a','c') ('a','d'), ('b','c'), ('b','d') and ('c','d'). Again, the relations parameter is a set of tuples, containing activity names and the retain parameter allows us to express whether or not we want to keep or remove the matching traces.
+* **filter_time_range(log, dt1, dt2, mode='events')**; Filters the event log based on a given time range, defined by timestamps dt1 and dt2. The timestamps should be of the form datetime.datetime. The filter has three modes (default: 'events'):
+
+    * *'events'*; Retains all events that fall in the provided time range. Removes any empty trace in the filtered event log.
+    * *'traces_contained'*; Retains any trace that is completely 'contained' within the given time frame. For example, this filter is useful if one is interested to retain all full traces in a specific day/month/year.
+    * *'traces_intersecting'*; Retains any trace that has at least one event that falls into the given time range.
+
+Consider the example code below, in which we provide various example applications of the mentioned filtering functions, using the running example event log. Try to copy-paste each line in your own environment and play around with the resulting filtered event log to get a good idea of the functionality of each filter. Note that, all functions shown below also work when providing a dataframe as an input!
+
+.. code-block:: python3
+
+    import pm4py
+    import datetime as dt
+
+    if __name__ == "__main__":
+        log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+
+        filtered = pm4py.filter_start_activities(log, {'register request'})
+
+        filtered = pm4py.filter_start_activities(log, {'register request TYPO!'})
+
+        filtered = pm4py.filter_end_activities(log, {'pay compensation'})
+
+        filtered = pm4py.filter_event_attribute_values(log, 'org:resource', {'Pete', 'Mike'})
+
+        filtered = pm4py.filter_event_attribute_values(log, 'org:resource', {'Pete', 'Mike'}, level='event')
+
+        filtered = pm4py.filter_trace_attribute_values(log, 'concept:name', {'3', '4'})
+
+        filtered = pm4py.filter_trace_attribute_values(log, 'concept:name', {'3', '4'}, retain=False)
+
+        filtered = pm4py.filter_variants(log, [
+            ['register request', 'check ticket', 'examine casually', 'decide', 'pay compensation']])
+
+        filtered = pm4py.filter_variants(log, [
+            ['register request', 'check ticket', 'examine casually', 'decide', 'reject request']])
+
+        filtered = pm4py.filter_directly_follows_relation(log, [('check ticket', 'examine casually')])
+
+        filtered = pm4py.filter_eventually_follows_relation(log, [('examine casually', 'reject request')])
+
+        filtered = pm4py.filter_time_range(log, dt.datetime(2010, 12, 30), dt.datetime(2010, 12, 31), mode='events')
+
+        filtered = pm4py.filter_time_range(log, dt.datetime(2010, 12, 30), dt.datetime(2010, 12, 31),
+                                           mode='traces_contained')
+
+        filtered = pm4py.filter_time_range(log, dt.datetime(2010, 12, 30), dt.datetime(2010, 12, 31),
+                                           mode='traces_intersecting')
+
+
+Discovering Your First Process Model
+------------------------------------
+
+Since we have studied basic conceptual knowledge of process mining and event data munging and crunching, we focus on process discovery. As indicated, the goal is to discover, i.e., primarily completely automated and algorithmically, a process model that accurately describes the process, i.e., as observed in the event data. For example, given the running example event data, we aim to discover the process model that we have used to explain the running example's process behavior, i.e., Figure 3. This section briefly explains what modeling formalisms exist in PM4Py while applying different process discovery algorithms. Secondly, we give an overview of the implemented process discovery algorithms, their output type(s), and how we can invoke them. Finally, we discuss the challenges of applying process discovery in practice.
+
+.. raw:: html
+
+	<!--<iframe width="560" height="315" src="https://www.youtube.com/embed/BJMp763Ye_o" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/BJMp763Ye_o" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #7 process discovery</a>
+
+Obtaining a Process Model
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+There are three different process modeling notations that are currently supported in PM4Py. These notations are: BPMN, i.e., models such as the ones shown earlier in this tutorial, Process Trees and Petri nets. A Petri net is a more mathematical modeling representation compared to BPMN. Often the behavior of a Petri net is more difficult to comprehend compared to BPMN models. However, due to their mathematical nature, Petri nets are typically less ambiguous (i.e., confusion about their described behavior is not possible). Process Trees represent a strict subset of Petri nets and describe process behavior in a hierarchical manner. In this tutorial, we will focus primarily on BPMN models and process trees. For more information about Petri nets and their application to (business) process modeling (from a ‘workflow’ perspective), we refer to
+`this article <https://www.researchgate.net/profile/Wil_Aalst/publication/220337578_The_Application_of_Petri_Nets_to_Workflow_Management/links/0deec517a563a45197000000/The-Application-of-Petri-Nets-to-Workflow-Management.pdf?_sg%5B0%5D=2TrqDbNsoZEr67XgOwI_9qxtlO_S1HJFHn8edW7aE0fMWzmsY0D1GhrsbRXdtZhTLvQ1KcSm9pkLzooDMl-eRg.DhnNamQg4EvK8MAwucwkB1VDke7eNq0E4jxMAa2IMXXZtvr9k1PPiwZpQEt1Z2iqkdkN-SOlWyjFloP-BivLow&_sg%5B1%5D=XeHToX2_7feAtM6yO395-HEYttSzdWJeiLaGlD_7Dn3hRXYnVXya0-dHm5RWmjX22gF3ton7d7FSzF6FjL_NYZCQzRvJuPg4zPWnk_HCe0xj.DhnNamQg4EvK8MAwucwkB1VDke7eNq0E4jxMAa2IMXXZtvr9k1PPiwZpQEt1Z2iqkdkN-SOlWyjFloP-BivLow&_iepl=>`_.
+
+Interestingly, none of the algorithms implemented in PM4Py directly discovers a BPMN model. However, any process tree can easily be translated to a BPMN model. Since we have already discussed the basic operators of BPMN models, we will start with the discovery of a process tree, which we convert to a BPMN model. Later, we will study the ‘underlying’ process tree. The algorithm that we are going to use is the ‘Inductive Miner’; More details about the (inner workings of the) algorithm can be found in
+`this presentation <http://www.processmining.org/_media/presentations/2013/petri_nets.pptx>`_ and in `this article <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.396.197&rep=rep1&type=pdf>`_. Consider the following code snippet. We discover a BPMN model (using a conversion from process tree to BPMN) using the inductive miner, based on the running example event data set.
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+
+        process_tree = pm4py.discover_process_tree_inductive(log)
+        bpmn_model = pm4py.convert_to_bpmn(process_tree)
+        pm4py.view_bpmn(bpmn_model)
+
+
+Note that the resulting process model is the following image:
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/bpmn_inductive_running_example.png
+
+*Figure 6: BPMN model discovered based on the running example event data set, using the Inductive Miner implementation of PM4Py.*
+
+Observe that the process model that we discovered, is indeed the same model as the model that we have used before, i.e., as shown in Figure 3.
+
+As indicated, the algorithm used in this example actually discovers a Process Tree. Such a process tree is, mathematically speaking, a
+`rooted tree <https://en.wikipedia.org/wiki/Tree_(graph_theory)>`_ annotated with ‘control-flow’ information. We’ll first use the following code snippet to discover a process tree based on the running example, and, afterwards shortly analyze the model.
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+
+        process_tree = pm4py.discover_process_tree_inductive(log)
+        pm4py.view_process_tree(process_tree)
+
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/process_tree_running_example.png
+
+*Figure 7: Process Tree model discovered based on the running example event data set, using the Inductive Miner implementation of PM4Py.*
+
+We the process tree model from top to bottom. The first circle, i.e., the ‘root’ of the process tree, describes a ‘->’ symbol. This means that, when srolling further down, the process described by the model executes the ‘children’ of the root from left to right. Hence, first “register request” is executed, followed by the circle node with the ‘*’ symbol, finally to be followed by the node with the ‘X’ symbol. The node with the ‘*’ represents ‘repeated behavior’, i.e., the possibility to repeat the behavior. When scrolling further down, the left-most ‘subtree’ of the ‘*’-operator is always executed, the right-most child (in this case, “reinitiate request”) triggers a repeated execution of the left-most child. Observe that this is in line with the process models we have seen before, i.e., the “reinitiate request” activity allows us to repeat the behavior regarding examinations and checking the ticket. When we go further down below in the subtree of the ‘*’-operator, we again observe a ‘->’ node. Hence, its left-most child is executed first, followed by its right-most child (“decide”). The left-most child of the ‘->’ node has a ‘+’ symbol. This represents concurrent behavior; hence, its children can be executed simultaneously or in any order. Its left-most child is the “check ticket” activity. Its right-most child is a node with an ‘X’ symbol (just like the right-most child of the tree's root). This represents an exclusive choice, i.e., one of the children is executed (either “examine casually” or “examine thoroughly”). Observe that the process tree describes the exact same behavior as the BPMN models shown before.
+
+Obtaining a Process Map
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Many `commercial process mining solutions <https://www.gartner.com/reviews/market/process-mining>`_ do not provide extended support for discovering process models. Often, as a main visualization of processes, process maps are used. A process map contains activities and connections (by means of arcs) between them. A connection between two activities usually means that there some form of precedence relation. In its simplest form, it means that the ‘source’ activity directly precedes the ‘target’ activity. Let’s quickly take a look at a concrete example! Consider the following code snippet, in which we learn a ‘Directly Follows Graph’ (DFG)-based process map:
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+
+        dfg, start_activities, end_activities = pm4py.discover_dfg(log)
+        pm4py.view_dfg(dfg, start_activities, end_activities)
+
+
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/dfg_running_example.png
+
+*Figure 8: Process Map (DFG-based) discovered based on the running example event data set.*
+
+The **pm4py.discover_dfg(log)** function returns a triple. The first result, i.e., called dfg in this example, is a dictionary mapping pairs of activities that follow each other directly, to the number of corresponding observations. The second and third arguments are the start and end activities observed in the event log (again counters). In the visualization, the green circle represents the start of any observed process instance. The orange circle represents the end of an observed process instance. In 6 cases, the register request is the first activity observed (represented by the arc labeled with value 6). In the event log, the check ticket activity is executed directly after the register request activity. The examine thoroughly activity is following registration once, examine casually follows 3 times. Note that, indeed, in total, the register activity is followed by 6 different events, i.e., there are 6 traces in the running example event log. However, note that there are typically much more relations observable compared to the number of cases in an event log. Even using this simple event data, the DFG-based process map of the process is much more complex than the process models learned earlier. Furthermore, it is much more difficult to infer the actual execution of the process based on the process map. Hence, when using process maps, one should be very carefully when trying to comprehend the actual process.
+
+In PM4Py, we also implemented the `Heuristics Miner <https://ieeexplore.ieee.org/iel5/5937059/5949295/05949453.pdf>`_, a more advanced process map discovery algorithm, compared to its DFG-based alternative. We won’t go into the algorithmic details here, however, in a HM-based process map, the arcs between activities represent observed concurrency. For example, the algorithm is able to detect that the ticket check and examination are concurrent. Hence, these activities will not be connected in the process map. As such, a HM-based process map is typically simpler compared to a DFG-based process map.
+
+.. code-block:: python3
+
+    import pm4py
+
+    if __name__ == "__main__":
+        log = pm4py.read_xes('C:/Users/demo/Downloads/running-example.xes')
+
+        map = pm4py.discover_heuristics_net(log)
+        pm4py.view_heuristics_net(map)
+
+
+.. image:: https://pm4py.fit.fraunhofer.de/static/assets/images/getting_started/hnet_running_example.png
+
+*Figure 9: Process Map (HM-based) discovered based on the running example event data set.*
+
+
+Conformance Checking
+------------------------------------
+
+.. raw:: html
+
+    <!--<iframe width="560" height="315" src="https://www.youtube.com/embed/0YNvijqX3FY" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>-->
+    <a href="https://www.youtube.com/embed/0YNvijqX3FY" target="_blank" rel="noopener noreferrer">→ Watch on YouTube: pm4py tutorials - tutorial #8 conformance checking</a>
+

pm4py/docs/source/index.rst

@@ -0,0 +1,32 @@
+Welcome to pm4py's Documentation!
+===================================
+
+``pm4py`` is a Python library implementing a variety of `process mining <https://en.wikipedia.org/wiki/Process_mining>`_ algorithms.
+
+A simple example of ``pm4py`` in action:
+
+.. code-block:: python
+
+   import pm4py
+
+   if __name__ == "__main__":
+       log = pm4py.read_xes('<path-to-xes-log-file.xes>')
+       process_model = pm4py.discover_bpmn_inductive(log)
+       pm4py.view_bpmn(process_model)
+					
+In this documentation, you can find all relevant information to set up ``pm4py`` and start your process mining journey. 
+Please consult the Contents listed below to navigate the documentation.
+
+Happy #processmining!
+
+
+Contents
+--------
+
+.. toctree::
+   :maxdepth: 2
+
+   install
+   getting_started
+   api
+   release_notes

pm4py/docs/source/install.rst

@@ -0,0 +1,32 @@
+Installation
+============
+
+pip
+---
+
+To use ``pm4py`` on any OS, install it using ``pip``:
+
+.. code-block:: console
+
+   (.venv) $ pip install pm4py
+
+``pmp4y`` uses the ``Graphviz`` library for rendering visualizations.
+Please install `Graphviz <https://graphviz.org/download/>`_.
+
+After installation, GraphViz is located in the ``program files`` directory. 
+The ``bin\`` folder of the GraphViz directory needs to be added manually to the ``system path``.
+In order to do so, please follow `this instruction <https://stackoverflow.com/questions/44272416/how-to-add-a-folder-to-path-environment-variable-in-windows-10-with-screensho>`_.
+
+Docker
+------
+To install pm4py via Docker, use:
+
+.. code-block:: console
+
+   $ docker pull pm4py/pm4py-core:latest
+
+To run pm4py via docker, use:
+
+.. code-block:: console
+
+   $ docker run -it pm4py/pm4py-core:latest bash

pm4py/docs/source/modules.rst

@@ -0,0 +1,7 @@
+pm4py-source
+============
+
+.. toctree::
+   :maxdepth: 4
+
+   pm4py

pm4py/docs/source/release_notes.rst

@@ -0,0 +1,114 @@
+Release Notes
+=============
+
+
+pm4py 2.7.0 - Release Notes
+---------------------------
+
+The major changes in pm4py 2.7.0 are as follows:
+
+1. We added an initial integration to ChatGPT
+
+2. We added some connectors for workstation-supported processes (Outlook mail and calendar; web browsers).
+
+
+pm4py 2.6.0 - Release Notes
+---------------------------
+
+The major changes in pm4py 2.6.0 are as follows:
+
+1. We added the ILP Miner as process discovery algorithm
+
+2. We added two log filters: "timestamp grouping" and "consecutive activities"
+
+3. We added the insertion of the case arrival/finish rate and of the waiting/service/sojourn times
+in the simplified interface
+
+4. We added a baseline clustering algorithm, based on the pre-existing feature extraction
+
+5. We added the extraction of the "target vector" from event logs for machine learning purposes
+
+
+pm4py 2.5.0 - Release Notes
+---------------------------
+
+The major changes in pm4py 2.5.0 are as follows:
+
+1. We added the Cardoso and extended Cardoso simplicity metrics to pm4py
+
+2. We added discovery of Stochastic Arc Weight nets based on OCEL logs.
+
+3. We added Murata-based Petri net simplification to the simplified interface (implicit place removal)   
+
+
+pm4py 2.4.0 - Release Notes
+---------------------------
+
+Today, we released pm4py 2.4.0.
+We have adopted our release policy slightly, i.e., as of now, the pm4py versioning follows the MAJOR.MINOR.FIX pattern.
+We will also report all MAJOR and MINOR releases in the release notes.
+
+As today's release is a minor release, we report on the main changes here.
+
+1. We added the Murata algorithm (Berthelot implementation) to remove the structurally redundant places, which is now available in the simplified interface.
+
+2. We added the reduction of invisible transitions in Petri nets to the simplified interface.
+
+3. We added support for calcuating stochastic languages of process models
+
+4. We adde support for calculating EMD between two stochastic languages 
+
+5. we added a visualization of alignments in simplified interface
+
+6. We added visualization of footprint table in simplified interface
+
+7. We added a conversion of Petri net objects to networkX DiGraphs
+
+8. We added support for stochastic Petri nets
+
+9. We added support for stochastic arc-weight nets (the paper describing this class of nets is submitted to the Petri nets 2023 conference)
+
+pm4py 2.3.0 - Release Notes
+---------------------------
+Finally, pm4py 2.3.0 has arrived!
+The 2.3.0 release contains various significant updates and improvements concerning its predecessors. 
+The release consists of approximately 550 commits and 47.000 LoC!
+The main changes are as follows:
+
+1. *Flexible parameter passing in the simplified method invocation*, e.g., :meth:`pm4py.discovery.discover_petri_net_inductive`; 
+For example, in ```pm4py``` 2.2.X, the columns used in process discovery were fixed (i.e., case:concept:name, concept:name, time:timestamp). Hence, changing the perspective implied changing column headers.
+In pm4py 2.3.X, the columns used in process discovery are now part of the function arguments.
+A simple comparison:
+  * Discovering a Petri net in pm4py 2.2.X:
+  ``pm4py.discover_petri_net_inductive(dataframe, noise_threshold=0.2)``
+
+  * Discovering a Petri net in pm4py 2.3.X:
+  ``pm4py.discover_petri_net_inductive(dataframe, noise_threshold=0.2, activity_key="activity", timestamp_key="timestamp", case_id_key="case")``
+
+2. *Dataframes are primary citizens*; 
+pm4py used to support both Pandas ``Dataframes`` and our custom-defined event log object. We have decided to adapt all algorithms to work on Dataframes. As such, event data is expected to be represented as a Dataframe in pm4py (i.e., we are dropping the explicit use of our custom event log object). There are two main reasons for this design decision:
+  1. *Performance*; Generally, Pandas Dataframes are performing significantly better on most operations compared to our custom event log object
+  2. *Practice*; Most real event data is of tabular form.
+
+Of course, pm4py still supports importing .xes files. However, when importing an event log using :meth:`pm4py.read.read_xes`, the object is directly converted into a Dataframe.
+A general drawback of this design decision is that pm4py no longer appropriately supports nested objects (generally supported by the .xes standard). However, as indicated in point b), such nested objects are rarely used in practice.
+ 
+3. *Typing Information in the simplified interface*; 
+All methods in the simplified interface are guaranteed to have typing information on their input and output objects.
+
+4. *Variant Representation*; 
+In pm4py 2.3.X, trace variants are represented as a tuple of Strings (representing activity names) instead of a String where a ‘,’ symbol indicates activity separation. For example, a variant of the form <A,B,C> is now represented as a tuple (‘A’,’B’,’C’) and was previously represented as ‘A,B,C’. This fix allows activity names to contain a ‘,’ symbol.
+
+5. *Inductive Miner Revised*;
+We have re-implemented and restructured the code of the inductive miner. The new version is closer to the reference implementation in ProM and is more performant than the previous version.
+
+6. *Business Hours Revised*; 
+The business hours functionality in pm4py has been revised completely. In pm4py 2.2.X, one could only specify the working days and hours, which were fixed. In pm4py 2.3.X, one can define week-day-based activity slots (e.g., to model breaks). One slot, i.e., one tuple consists of one start and one end time given in seconds since week start, e.g. [(7 * 60 * 60, 17 * 60 * 60), ((24 + 7) * 60 * 60, (24 + 12) * 60 * 60), ((24 + 13) * 60 * 60, (24 + 17) * 60 * 60),] meaning that business hours are Mondays 07:00 - 17:00 and Tuesdays 07:00 - 12:00 and 13:00 - 17:00
+
+7. *Auto-Generated Docs*; 
+As you may have noticed, this website serves as the new documentation hub for pm4py. It contains all previously available information on the project website related to ‘installation’ and ‘getting started’. For the simplified interface, we have merged the general documentation with the API docs to improve the overall understanding of working with pm4py. The docs are now generated directly from the pm4py source. Hence, feel free to share a pull request if you find any issues.
+
+
+Happy #processmining!
+
+The #pm4py development team.

pm4py/examples/CHECK_MISSING.py

@@ -0,0 +1,9 @@
+import os
+
+
+if __name__ == "__main__":
+    files = [x.split(".")[0] for x in os.listdir(".") if x.endswith(".py") and not "execute_everything" in x and not "CHECK_MISSING" in x]
+    contents_ex_everything = open("execute_everything.py", "r").read()
+    for f in files:
+        if f not in contents_ex_everything:
+            print(f)

pm4py/examples/activities_to_alphabet.py

@@ -0,0 +1,13 @@
+import pm4py
+from pm4py.objects.log.util import activities_to_alphabet
+from pm4py.util import constants
+
+
+def execute_script():
+    dataframe = pm4py.read_xes("../tests/input_data/running-example.xes", return_legacy_log_object=False)
+    renamed_dataframe = activities_to_alphabet.apply(dataframe, parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: "concept:name"})
+    print(renamed_dataframe)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/activity_position.py

@@ -0,0 +1,16 @@
+import pm4py
+from pm4py.util import constants, pandas_utils
+from pm4py.objects.log.util import dataframe_utils
+import os
+
+
+def execute_script():
+    dataframe = pandas_utils.read_csv(os.path.join("..", "tests", "input_data", "receipt.csv"))
+    dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"])
+    # prints the summary of the positions of two activities
+    print(pm4py.get_activity_position_summary(dataframe, "Confirmation of receipt"))
+    print(pm4py.get_activity_position_summary(dataframe, "T02 Check confirmation of receipt"))
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/align_approx_pt.py

@@ -0,0 +1,27 @@
+import os
+import importlib.util
+from pm4py.algo.discovery.inductive import algorithm as inductive
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.algo.conformance.alignments.process_tree import algorithm as align_approx
+from pm4py.objects.petri_net.utils.align_utils import pretty_print_alignments
+from examples import examples_conf
+
+
+def execute_script():
+    log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
+
+    log = xes_importer.apply(log_path)
+    tree = inductive.apply(log)
+
+    if importlib.util.find_spec("graphviz"):
+        from pm4py.visualization.process_tree import visualizer as pt_vis
+        gviz = pt_vis.apply(tree, parameters={pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT})
+        pt_vis.view(gviz)
+
+    print("start calculate approximated alignments")
+    approx_alignments = align_approx.apply(log, tree)
+    pretty_print_alignments(approx_alignments)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/align_decomposition_ex_paper.py

@@ -0,0 +1,99 @@
+from pm4py.objects.petri_net.obj import PetriNet, Marking
+from pm4py.objects.petri_net.utils.petri_utils import add_arc_from_to
+from pm4py.objects.petri_net.utils import decomposition
+from examples import examples_conf
+import importlib.util
+
+
+def execute_script():
+    net = PetriNet("")
+    start = PetriNet.Place("start")
+    end = PetriNet.Place("end")
+    c1 = PetriNet.Place("c1")
+    c2 = PetriNet.Place("c2")
+    c3 = PetriNet.Place("c3")
+    c4 = PetriNet.Place("c4")
+    c5 = PetriNet.Place("c5")
+    c6 = PetriNet.Place("c6")
+    c7 = PetriNet.Place("c7")
+    c8 = PetriNet.Place("c8")
+    c9 = PetriNet.Place("c9")
+    net.places.add(c1)
+    net.places.add(c2)
+    net.places.add(c3)
+    net.places.add(c4)
+    net.places.add(c5)
+    net.places.add(c6)
+    net.places.add(c7)
+    net.places.add(c8)
+    net.places.add(c9)
+    net.places.add(start)
+    net.places.add(end)
+    t1 = PetriNet.Transition("t1", "a")
+    t2 = PetriNet.Transition("t2", None)
+    t3 = PetriNet.Transition("t3", "b")
+    t4 = PetriNet.Transition("t4", "c")
+    t5 = PetriNet.Transition("t5", "d")
+    t6 = PetriNet.Transition("t6", "e")
+    t7 = PetriNet.Transition("t7", None)
+    t8 = PetriNet.Transition("t8", "f")
+    t9 = PetriNet.Transition("t9", "g")
+    t10 = PetriNet.Transition("t10", "h")
+    t11 = PetriNet.Transition("t11", None)
+    net.transitions.add(t1)
+    net.transitions.add(t2)
+    net.transitions.add(t3)
+    net.transitions.add(t4)
+    net.transitions.add(t5)
+    net.transitions.add(t6)
+    net.transitions.add(t7)
+    net.transitions.add(t8)
+    net.transitions.add(t9)
+    net.transitions.add(t10)
+    net.transitions.add(t11)
+    add_arc_from_to(start, t1, net)
+    add_arc_from_to(t1, c1, net)
+    add_arc_from_to(t1, c2, net)
+    add_arc_from_to(c1, t2, net)
+    add_arc_from_to(c1, t3, net)
+    add_arc_from_to(c2, t4, net)
+    add_arc_from_to(t2, c3, net)
+    add_arc_from_to(t3, c3, net)
+    add_arc_from_to(t4, c4, net)
+    add_arc_from_to(c3, t5, net)
+    add_arc_from_to(c4, t5, net)
+    add_arc_from_to(t5, c5, net)
+    add_arc_from_to(c5, t6, net)
+    add_arc_from_to(t6, c1, net)
+    add_arc_from_to(t6, c2, net)
+    add_arc_from_to(c5, t7, net)
+    add_arc_from_to(t7, c7, net)
+    add_arc_from_to(t7, c6, net)
+    add_arc_from_to(c7, t8, net)
+    add_arc_from_to(c6, t9, net)
+    add_arc_from_to(t8, c8, net)
+    add_arc_from_to(t9, c9, net)
+    add_arc_from_to(c8, t11, net)
+    add_arc_from_to(c9, t11, net)
+    add_arc_from_to(t11, end, net)
+    add_arc_from_to(c5, t10, net)
+    add_arc_from_to(t10, end, net)
+    im = Marking()
+    im[start] = 1
+    fm = Marking()
+    fm[end] = 1
+    decomposed_net = decomposition.decompose(net, im, fm)
+    gvizs = []
+
+    if importlib.util.find_spec("graphviz"):
+        from pm4py.visualization.petri_net import visualizer
+
+        gvizs.append(visualizer.apply(net, im, final_marking=fm, parameters={"format": examples_conf.TARGET_IMG_FORMAT}))
+        visualizer.view(gvizs[len(gvizs) - 1])
+        for snet, sim, sfm in decomposed_net:
+            gvizs.append(visualizer.apply(snet, sim, final_marking=sfm, parameters={"format": examples_conf.TARGET_IMG_FORMAT}))
+            visualizer.view(gvizs[len(gvizs) - 1])
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/align_decomposition_example.py

@@ -0,0 +1,29 @@
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.algo.discovery.inductive import algorithm as inductive_miner
+from pm4py.algo.conformance.alignments.decomposed import algorithm as dec_align
+from pm4py.algo.evaluation.replay_fitness import algorithm as rep_fit
+from pm4py.objects.conversion.process_tree import converter as process_tree_converter
+import os
+import time
+
+
+def execute_script():
+    # import the a32f0n00 log
+    log = xes_importer.apply(os.path.join("..", "tests", "compressed_input_data", "09_a32f0n00.xes.gz"))
+    # discover a model using the inductive miner
+    process_tree = inductive_miner.apply(log)
+    net, im, fm = process_tree_converter.apply(process_tree)
+    # apply the alignments decomposition with a maximal number of border disagreements set to 5
+    aa = time.time()
+    aligned_traces = dec_align.apply(log, net, im, fm, parameters={
+        dec_align.Variants.RECOMPOS_MAXIMAL.value.Parameters.PARAM_THRESHOLD_BORDER_AGREEMENT: 5})
+    bb = time.time()
+    print(bb-aa)
+    # print(aligned_traces)
+    # calculate the fitness over the recomposed alignment (use the classical evaluation)
+    fitness = rep_fit.evaluate(aligned_traces, variant=rep_fit.Variants.ALIGNMENT_BASED)
+    print(fitness)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/alignment_discounted_a_star.py

@@ -0,0 +1,52 @@
+import os
+import time
+from pm4py.algo.conformance.alignments.petri_net import algorithm as ali
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.objects.petri_net.importer import importer as petri_importer
+
+
+def testSynchronousDiscountedAlignment():
+    '''
+    This function runs an alignment based on the discounted edit distance
+    By using the synchronous product
+    :return:
+    '''
+    log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
+    pnml_path = os.path.join("..", "tests", "input_data", "running-example.pnml")
+    log = xes_importer.apply(log_path)
+    net, marking, fmarking = petri_importer.apply(pnml_path)
+
+    # to see the net :
+    #vizu(net,marking,fmarking).view()
+
+    start=time.time()
+
+    alignments1 = ali.apply(log._list[0], net, marking, fmarking,
+                            variant=ali.VERSION_DISCOUNTED_A_STAR,
+                            parameters={ali.Parameters.SYNCHRONOUS:True,ali.Parameters.EXPONENT:1.1})
+    print(alignments1)
+    print("Time:",(time.time()-start))
+
+def testNoSynchronousDiscountedAlignment():
+    '''
+    This function runs an alignment based on the discounted edit distance
+    By using the Petri net and petri_net.utils.align_utils.discountedEditDistance function
+    '''
+    log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
+    pnml_path = os.path.join("..", "tests", "input_data", "running-example.pnml")
+    log = xes_importer.apply(log_path)
+    net, marking, fmarking = petri_importer.apply(pnml_path)
+
+    start=time.time()
+
+    alignments1 = ali.apply(log._list[0], net, marking, fmarking,
+                            variant=ali.VERSION_DISCOUNTED_A_STAR,
+                            parameters={ali.Parameters.SYNCHRONOUS:False,ali.Parameters.EXPONENT:1.1})
+    print(alignments1)
+    print("Time:",(time.time()-start))
+
+
+if __name__ == '__main__':
+    # example on the first trace
+    testSynchronousDiscountedAlignment()
+    testNoSynchronousDiscountedAlignment()

pm4py/examples/alignment_test.py

@@ -0,0 +1,50 @@
+import os
+
+from pm4py import util
+from pm4py.algo.conformance import alignments as ali
+from pm4py.algo.conformance.alignments.petri_net.variants.state_equation_a_star import Parameters
+from pm4py.objects import log as log_lib
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.objects.petri_net.importer import importer as petri_importer
+from pm4py.objects.petri_net.utils.align_utils import pretty_print_alignments
+
+
+def align(trace, net, im, fm, model_cost_function, sync_cost_function):
+    trace_costs = list(map(lambda e: 1000, trace))
+    params = dict()
+    params[util.constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = log_lib.util.xes.DEFAULT_NAME_KEY
+    params[Parameters.PARAM_MODEL_COST_FUNCTION] = model_cost_function
+    params[Parameters.PARAM_TRACE_COST_FUNCTION] = trace_costs
+    params[Parameters.PARAM_SYNC_COST_FUNCTION] = sync_cost_function
+    return ali.petri_net.algorithm.apply_trace(trace, net, im, fm, parameters=params,
+                                   variant=ali.petri_net.algorithm.VERSION_STATE_EQUATION_A_STAR)
+
+
+def execute_script():
+    log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
+    pnml_path = os.path.join("..", "tests", "input_data", "running-example.pnml")
+
+    # log_path = 'C:/Users/bas/Documents/tue/svn/private/logs/a32_logs/a32f0n05.xes'
+    # pnml_path = 'C:/Users/bas/Documents/tue/svn/private/logs/a32_logs/a32.pnml'
+
+    log = xes_importer.apply(log_path)
+    net, marking, fmarking = petri_importer.apply(pnml_path)
+
+    model_cost_function = dict()
+    sync_cost_function = dict()
+    for t in net.transitions:
+        if t.label is not None:
+            model_cost_function[t] = 1000
+            sync_cost_function[t] = 0
+        else:
+            model_cost_function[t] = 1
+
+    alignments = []
+    for trace in log:
+        alignments.append(align(trace, net, marking, fmarking, model_cost_function, sync_cost_function))
+
+    pretty_print_alignments(alignments)
+
+
+if __name__ == '__main__':
+    execute_script()

pm4py/examples/all_optimal_alignments.py

@@ -0,0 +1,18 @@
+import pm4py
+from pm4py.algo.conformance.alignments.petri_net.variants import generator_dijkstra_less_memory
+import os
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes"), return_legacy_log_object=True)
+
+    net, im, fm = pm4py.discover_petri_net_inductive(log)
+
+    for trace in log:
+        print("\n\n")
+        for ali in generator_dijkstra_less_memory.apply(trace, net, im, fm):
+            print(ali)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/antialignments_and_precision.py

@@ -0,0 +1,23 @@
+import os
+
+from pm4py.algo.conformance.antialignments.variants.discounted_a_star import apply as antii
+from pm4py.algo.conformance.antialignments.algorithm import Parameters
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.objects.petri_net.importer import importer as petri_importer
+
+
+if __name__ == '__main__':
+    log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
+    pnml_path = os.path.join("..", "tests", "input_data", "running-example.pnml")
+    log = xes_importer.apply(log_path)
+    net, marking, fmarking = petri_importer.apply(pnml_path)
+
+    THETA = 1.5
+    MU =  20
+    EPSILON = 0.01
+    resAnti = antii(log,net,marking,fmarking, parameters={Parameters.EXPONENT:THETA,
+                                                          Parameters.EPSILON:EPSILON,
+                                                          Parameters.MARKING_LIMIT:MU})
+    print(resAnti['anti-alignment'])
+    print("Precision:",resAnti['precision'])
+

pm4py/examples/backwards_token_replay.py

@@ -0,0 +1,18 @@
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.algo.discovery.inductive import algorithm as inductive_miner
+from pm4py.algo.conformance.tokenreplay import algorithm as tr
+from pm4py.objects.conversion.process_tree import converter as process_tree_converter
+import os
+
+
+def execute_script():
+    log = xes_importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes"))
+    process_tree = inductive_miner.apply(log)
+    net, im, fm = process_tree_converter.apply(process_tree)
+    # perform the backwards token-based replay
+    replayed_traces = tr.apply(log, net, im, fm, variant=tr.Variants.BACKWARDS)
+    print(replayed_traces)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/batch_detection.py

@@ -0,0 +1,18 @@
+import pm4py
+from pm4py.algo.discovery.batches import algorithm
+import os
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes"))
+    # detect the batches from the event log
+    batches = algorithm.apply(log)
+    # print the batches (complete information) in a single row
+    print(batches)
+    # print a summary information (size) for each activity-resource combination that is performed in batches
+    for batch in batches:
+        print(batch[0], batch[1])
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/bpmn_from_pt_conversion.py

@@ -0,0 +1,26 @@
+import os
+
+import pm4py
+from pm4py.objects.conversion.process_tree import converter as pt_converter
+from pm4py.algo.discovery.inductive import algorithm as inductive_miner
+from pm4py.objects.log.importer.xes import importer as xes_import
+from pm4py.objects.bpmn.exporter import exporter as bpmn_exporter
+from examples import examples_conf
+import importlib.util
+
+
+
+def execute_script():
+    log_path = os.path.join(os.path.join("..", "tests", "input_data", "running-example.xes"))
+    log = xes_import.apply(log_path)
+    ptree = inductive_miner.apply(log)
+    bpmn = pt_converter.apply(ptree, variant=pt_converter.Variants.TO_BPMN)
+
+    if importlib.util.find_spec("graphviz"):
+        bpmn_exporter.apply(bpmn, "stru.bpmn")
+        os.remove("stru.bpmn")
+        pm4py.view_bpmn(bpmn, format=examples_conf.TARGET_IMG_FORMAT)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/bpmn_import_and_to_petri_net.py

@@ -0,0 +1,20 @@
+import os
+
+import pm4py
+from pm4py.objects.bpmn.importer import importer as bpmn_importer
+from pm4py.objects.conversion.bpmn import converter as bpmn_converter
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes"))
+    bpmn_graph = bpmn_importer.apply(os.path.join("..", "tests", "input_data", "running-example.bpmn"))
+    net, im, fm = bpmn_converter.apply(bpmn_graph, variant=bpmn_converter.Variants.TO_PETRI_NET)
+    precision_tbr = pm4py.precision_token_based_replay(log, net, im, fm)
+    print("precision", precision_tbr)
+    fitness_tbr = pm4py.precision_token_based_replay(log, net, im, fm)
+    print("fitness", fitness_tbr)
+    print(pm4py.check_soundness(net, im, fm))
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/bpmn_js_visualization.py

@@ -0,0 +1,15 @@
+import pm4py
+import importlib.util
+
+
+def execute_script():
+    log = pm4py.read_xes("../tests/input_data/running-example.xes")
+
+    bpmn_model = pm4py.discover_bpmn_inductive(log)
+
+    if importlib.util.find_spec("graphviz"):
+        pm4py.view_bpmn(bpmn_model, variant_str="dagrejs")
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/case_overlap_stat.py

@@ -0,0 +1,15 @@
+import pm4py
+import os
+from pm4py.statistics.overlap.cases.log import get as case_overlap_get
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes"))
+    # calculates the WIP statistics from the event log object.
+    # The WIP statistic associates to each case the number of cases open during the lifecycle of the case
+    wip = case_overlap_get.apply(log)
+    print(wip)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/consecutive_act_case_grouping_filter.py

@@ -0,0 +1,13 @@
+import pm4py
+from pm4py.algo.filtering.pandas.consecutive_act_case_grouping import consecutive_act_case_grouping_filter
+
+
+def execute_script():
+    dataframe = pm4py.read_xes("../tests/input_data/receipt.xes")
+    print(dataframe)
+    filtered_dataframe = consecutive_act_case_grouping_filter.apply(dataframe)
+    print(filtered_dataframe)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/corr_mining.py

@@ -0,0 +1,40 @@
+from pm4py.util import constants, pandas_utils
+
+from pm4py.algo.discovery.correlation_mining import algorithm as correlation_miner
+from pm4py.objects.log.util import dataframe_utils
+from pm4py.statistics.service_time.pandas import get as soj_time_get
+from pm4py.statistics.start_activities.pandas import get as sa_get
+from pm4py.statistics.end_activities.pandas import get as ea_get
+from examples import examples_conf
+import importlib.util
+
+
+def execute_script():
+    df = pandas_utils.read_csv("../tests/input_data/interval_event_log.csv")
+    df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT)
+    act_count = dict(df["concept:name"].value_counts())
+    parameters = {}
+    parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp"
+    parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp"
+    parameters["format"] = examples_conf.TARGET_IMG_FORMAT
+    start_activities = sa_get.get_start_activities(df, parameters=parameters)
+    end_activities = ea_get.get_end_activities(df, parameters=parameters)
+    parameters["start_activities"] = start_activities
+    parameters["end_activities"] = end_activities
+    soj_time = soj_time_get.apply(df, parameters=parameters)
+    dfg, performance_dfg = correlation_miner.apply(df, variant=correlation_miner.Variants.CLASSIC,
+                                                   parameters=parameters)
+
+    if importlib.util.find_spec("grapviz"):
+        from pm4py.visualization.dfg import visualizer as dfg_vis
+        gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, serv_time=soj_time, variant=dfg_vis.Variants.FREQUENCY,
+                                  parameters=parameters)
+        dfg_vis.view(gviz_freq)
+        gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, serv_time=soj_time,
+                                  variant=dfg_vis.Variants.PERFORMANCE,
+                                  parameters=parameters)
+        dfg_vis.view(gviz_perf)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/cost_based_dfg.py

@@ -0,0 +1,19 @@
+import pm4py
+import os
+from pm4py.algo.discovery.dfg.adapters.pandas import df_statistics
+from examples import examples_conf
+import importlib.util
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "roadtraffic100traces.xes"), return_legacy_log_object=False)
+    cost_based_dfg = df_statistics.get_dfg_graph(log, measure="cost", cost_attribute="amount")
+
+    if importlib.util.find_spec("grapviz"):
+        from pm4py.visualization.dfg import visualizer as dfg_visualizer
+        gviz = dfg_visualizer.apply(cost_based_dfg, variant=dfg_visualizer.Variants.COST, parameters={"format": examples_conf.TARGET_IMG_FORMAT})
+        dfg_visualizer.view(gviz)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/cycle_time.py

@@ -0,0 +1,14 @@
+import os
+
+import pm4py
+from pm4py.statistics.traces.cycle_time.log import get as cycle_time_get
+
+
+def execute_script():
+    log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "interval_event_log.xes"))
+    print(cycle_time_get.apply(log, parameters={cycle_time_get.Parameters.START_TIMESTAMP_KEY: "start_timestamp",
+                                                cycle_time_get.Parameters.TIMESTAMP_KEY: "time:timestamp"}))
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/data_petri_nets.py

@@ -0,0 +1,46 @@
+import os
+
+import pm4py
+from pm4py.algo.conformance.alignments.petri_net import algorithm as alignments
+from pm4py.objects.petri_net.data_petri_nets import semantics
+from pm4py.objects.petri_net.data_petri_nets.data_marking import DataMarking
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from examples import examples_conf
+import importlib.util
+
+
+def get_trans_by_name(net, name):
+    ret = [x for x in net.transitions if x.name == name]
+    if len(ret) == 0:
+        return None
+    return ret[0]
+
+
+def execute_script():
+    log = xes_importer.apply(os.path.join("..", "tests", "input_data", "roadtraffic100traces.xes"))
+    net, im, fm = pm4py.read_pnml(os.path.join("..", "tests", "input_data", "data_petri_net.pnml"), auto_guess_final_marking=True)
+
+    if importlib.util.find_spec("graphviz"):
+        pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT)
+
+    aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY, parameters={"ret_tuple_as_trans_desc": True})
+    for index, trace in enumerate(log):
+        aligned_trace = aligned_traces[index]
+        al = [(x[0][0], get_trans_by_name(net, x[0][1])) for x in aligned_trace["alignment"]]
+        m = DataMarking(im)
+        idx = 0
+        for el in al:
+            if el[1] is not None:
+                en_t = semantics.enabled_transitions(net, m, trace[min(idx, len(trace) - 1)])
+                if el[1] in en_t:
+                    if "guard" in el[1].properties:
+                        print(el[1], "GUARD SATISFIED", el[1].properties["guard"], m)
+                    m = semantics.execute(el[1], net, m, trace[min(idx, len(trace) - 1)])
+                else:
+                    print("TRANSITION UNAVAILABLE! Guards are blocking")
+            if el[0] != ">>":
+                idx = idx + 1
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/dataframe_prefix_and_fea_extraction.py

@@ -0,0 +1,23 @@
+from pm4py.objects.log.util import dataframe_utils
+from pm4py.util import pandas_utils, constants
+
+
+def execute_script():
+    # loads a dataframe. setup dates
+    df = pandas_utils.read_csv("../tests/input_data/receipt.csv")
+    df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT)
+    print(df)
+    # insert the case index in the dataframe
+    df = pandas_utils.insert_ev_in_tr_index(df, case_id="case:concept:name", column_name="@@index_in_trace")
+    # filter all the prefixes of length 5 from the dataframe
+    df = df[df["@@index_in_trace"] <= 5]
+    print(df)
+    # performs the automatic feature extraction
+    fea_df = dataframe_utils.automatic_feature_extraction_df(df)
+    print("\nfea_df =")
+    print(fea_df)
+    print(fea_df.columns)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/dec_treplay_imdf.py

@@ -0,0 +1,35 @@
+import os
+
+from pm4py.algo.discovery.inductive import algorithm as inductive_miner
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.objects.conversion.process_tree import converter as process_tree_converter
+from examples import examples_conf
+import importlib.util
+
+
+def execute_script():
+    # import the log
+    log_path = os.path.join("..", "tests", "input_data", "receipt.xes")
+    log = xes_importer.apply(log_path)
+    # apply Inductive Miner
+    process_tree = inductive_miner.apply(log)
+    net, initial_marking, final_marking = process_tree_converter.apply(process_tree)
+
+    if importlib.util.find_spec("graphviz"):
+        from pm4py.visualization.petri_net import visualizer as pn_vis
+        # get visualization
+        variant = pn_vis.Variants.PERFORMANCE
+        parameters_viz = {pn_vis.Variants.PERFORMANCE.value.Parameters.AGGREGATION_MEASURE: "mean", pn_vis.Variants.PERFORMANCE.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}
+        gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant,
+                            parameters=parameters_viz)
+        pn_vis.view(gviz)
+        # do another visualization with frequency
+        variant = pn_vis.Variants.FREQUENCY
+        parameters_viz = {pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}
+        gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant,
+                            parameters=parameters_viz)
+        pn_vis.view(gviz)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/decisiontree_align_example.py

@@ -0,0 +1,28 @@
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.algo.discovery.inductive import algorithm as inductive_miner
+from pm4py.algo.decision_mining import algorithm
+from pm4py.objects.conversion.process_tree import converter as process_tree_converter
+from examples import examples_conf
+import os
+import importlib.util
+
+
+def execute_script():
+    # in this case, we obtain a decision tree by alignments on a specific decision point
+    log = xes_importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes"))
+    process_tree = inductive_miner.apply(log)
+    net, im, fm = process_tree_converter.apply(process_tree)
+
+    if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"):
+        # we need to specify a decision point. In this case, the place p_10 is a suitable decision point
+        clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_10")
+
+        # we can visualize the decision tree
+        from pm4py.visualization.decisiontree import visualizer as visualizer
+        gviz = visualizer.apply(clf, feature_names, classes,
+                                parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT})
+        visualizer.view(gviz)
+
+
+if __name__ == "__main__":
+    execute_script()

pm4py/examples/decisiontree_trivial_example.py

@@ -0,0 +1,45 @@
+import os
+
+from pm4py.util import ml_utils
+from pm4py.objects.log.importer.xes import importer as xes_importer
+from pm4py.objects.log.util import get_class_representation
+from pm4py.algo.transformation.log_to_features import algorithm as log_to_features
+from examples import examples_conf
+import importlib.util
+
+
+def execute_script():
+    log_path = os.path.join("..", "tests", "input_data", "roadtraffic50traces.xes")
+    # log_path = os.path.join("..", "tests", "input_data", "receipt.xes")
+    log = xes_importer.apply(log_path)
+    # now, it is possible to get a default representation of an event log
+    data, feature_names = log_to_features.apply(log, variant=log_to_features.Variants.TRACE_BASED)
+    # gets classes representation by final concept:name value (end activity)
+    target, classes = get_class_representation.get_class_representation_by_str_ev_attr_value_value(log, "concept:name")
+
+    if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"):
+        # mine the decision tree given 'data' and 'target'
+        clf = ml_utils.DecisionTreeClassifier(max_depth=7)
+        clf.fit(data, target)
+
+        # visualize the decision tree
+        from pm4py.visualization.decisiontree import visualizer as dt_vis
+        gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT})
+        dt_vis.view(gviz)
+
+    # gets classes representation by trace duration (threshold between the two classes = 200D)
+    target, classes = get_class_representation.get_class_representation_by_trace_duration(log, 2 * 8640000)
+
+    if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"):
+        # mine the decision tree given 'data' and 'target'
+        clf = ml_utils.DecisionTreeClassifier(max_depth=7)
+        clf.fit(data, target)
+
+        # visualize the decision tree
+        from pm4py.visualization.decisiontree import visualizer as dt_vis
+        gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT})
+        dt_vis.view(gviz)
+
+
+if __name__ == "__main__":
+    execute_script()