semvec/pypi-packages huggingface dataset:
ProcessMeaningPatternsPython 0.11
An app to map event logs into ontology-based process knowledge and analyze the data through a library of knowledge patterns
License: MIT
Requires Python: >=3.9

# Process Meaning Patterns - Python Repository

Process Meaning Patterns is a framework designed to enable ontology-aware process mining. Ontology-aware process mining is meant to formalize process knowledge applied throughout the process mining lifecycle to enable transparency and replicability. This is accomplished through *process meaning patterns*, first-order logic ontology patterns that correspond to common verification and inference steps in the process mining lifecycle. This repository contains an implementation of the process meaning pattern framework implemented in python and supporting exporting of process knowledge to various formats including OWL/RDF, First order logic via CLIF or Prover9 syntax, and prolog/datalog. 

The process meaning patterns framework is actively maintaned and developed by [Riley Moher](https://riley-momo.github.io/) of the semantic technologies (stl) laboratory at the University of Toronto.

## Example Usage

The central object of the process meaning pattern library is the LogProcessor, which can ingest a business process event log in a variety of formats and output corresponding facts to be validated against or queried with process meaning patterns. Here is a simple example:

```python
import ProMean4Py

# define column names
col_dict = {'case_id': 'caseID', 'activity': 'activityID', 'timestamp': 'timestamp', 'resource': 'resourceID', 'event_id' : 'eventID'}
# create output directory
output_dir= '../output/testing/'
# define namespaces for knowledge graph
namespaces = {'ex' : "http://example.com/", 'on' : "https://stl.mie.utoronto.ca/ontologies/spm/"}
# initialize the log processor on some data
log_processor = LogProcessor('sample_log.csv', process_name='P1', column_dict=col_dict, prefixes=namespaces)
# save the event log facts as a knowledge graph
log_processor.save_knowledge_graph(output_dir, format='xml')
# save the event log facts as first-order-logic facts
log_processor.save_FOL(output_dir)
# save the event log facts as datalog facts
log_processor.save_datalog(output_dir)

```


More thorough examples, including an example utilizing real-world enterprise data, are available in the notebooks directory of this repository.


## Installation

ProMean4Py is published on the python package index (pypi) and can be installed on any python version >= 3.9.X by simply invoking pip:

`pip install ProcessMeaningPatternsPython`

## Release Notes

Release notes are tracked in the CHANGELOG.md file of this repository.
acme_project_create 0.0.7
Sets up a new (python) project using a template
License: MIT
Requires Python: >=3.9

# acme-project-create

Sets up a new (python) project using a template.

Uses a three-step process:
1. Template files are copied to the `-target-dir` location from a `--template-dir-path` directory. Default template for a python project is included in the package.
2. Directory names in the template following the pattern `{{<variable>}}` are substituted with value provided by the user.
3. Filenames in the template directory that end with `j2template` (e.g. `pyproject.toml.j2template`) are assumed to be `Jinja2` templates and a file is generated in the target location with variable substitutions provided by the user i.e. `pyproject.toml`.

And that's it.

Note: to provide all values to compile the template
the template dir needs to contain a `template_manifest.py` file that must implement a function:

`def configure_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser`

which takes an existing instance of ArgumentParser, adds arguments specific to the template and returns the parser object.

# Default template

The default template makes several notable choices:

* Uses `venv` for virtual environments and `.venv` dir to store built environment (and `uv` to build it)
* Uses `.env` file for setting up environment variables
* Uses `setuptools` for packaging
* Uses `pytest` for testing
* Uses `mkdocs` for documentation

# Problem

Setting up all files to create a new project is time consuming and involves lots of small technical choices.

# Why use this project?

You are probably better off using [Cookiecutter](https://github.com/cookiecutter/cookiecutter)

## Example usage

    apc -target-dir . -project-name hello-world -desc "Say hello to the world" -package-name hello_world -command hello -owner-email hello@example.com

# Project template

This project has been setup with `acme-project-create`, a python code template library.

# Required setup post use

* Enable GitHub Pages to be published via [GitHub Actions](https://docs.github.com/en/pages/getting-started-with-github-pages/configuring-a-publishing-source-for-your-github-pages-site#publishing-with-a-custom-github-actions-workflow)
* Create `release` environment for [GitHub Actions](https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-deployments/managing-environments-for-deployment#creating-an-environment)
* Setup auth to PyPI for the GitHub Action implemented in `release.yml`: [Link](https://docs.pypi.org/trusted-publishers/adding-a-publisher/) & uv publish [doc](https://docs.astral.sh/uv/guides/publish/#publishing-your-package)
* Once you create the python environment for the first time add the `uv.lock` file that will be created in project directory to the source control and update it each time environment is rebuilt
* Run `pre-commit install` to install the pre-commit hooks.