semvec/pypi-packages huggingface dataset:
rpeasings 0.4.6
Robert Penner's easings functions in python

# Robert Penner's Easing Functions

## SYNOPSIS

    `rpeasings.EASING_FUNCTION(t: float) -> float

returns `t` (between 0 and 1) eased by the chosen function.

## DESCRIPTION

There are a plethora of versions available of these, many of which provide an
object oriented interface, while most of the original easing functions could
be simple inline expressions.

This library takes the purely functional approach.  No class instantiation,
just a function call.

See https://easings.net for a good visualisation of these to chose the right
one.

Alternatively, if you have pygame-ce installed, you can launch the
`rpeasings-catalog.py` script in the `catalog` folder.  This will not work on
the outdated "official" pygame release.

## Module contents

With the exception of `null`, `in_expx` and `out_expx`, this is a pure python
port of "Penner's Easing Functions", based on the js code from
https://easings.net where you can also see a catalog of them in action to
chose the right one.

The following functions are included:

    in_back         out_back        in_out_back
    in_bounce       out_bounce      in_out_bounce
    in_circ         out_circ        in_out_circ
    in_cubic        out_cubic       in_out_cubic
    in_elastic      out_elastic     in_out_elastic
    in_expo         out_expo        in_out_expo
    in_quad         out_quad        in_out_quad
    in_quart        out_quart       in_out_quart
    in_quint        out_quint       in_out_quint
    in_sine         out_sine        in_out_sine

Additionally, I added a 'null' function, so easing can be disabled without
changing the interface in the application.  It's basically a `nop`.

    null(t) -> t

In case you want to control the easing function by user input, the `easings`
dictionary provides a map from function names to functions, e.g.

    eased = rpeasings.easings['out_elastic']

To use any of the included functions, create a `t` (for 'time') value in the
range 0-1 from your required range (e.g. `t = current / max`).

Putting this `t` into most(!) easing function, will give you a new 'eased'
value in the range 0-1.

Note: the following functions over-/undershoot:

    `in_back`     `out_back`     `in_out_back`
    `in_elastic`  `out_elastic`  `in_out_elastic`

You can then use this value as a factor or e.g. as input for another `lerp`
function.

Have fun, once you started using one, you'll probably find usecases for them
everywhere in your game...
exact-clustering 0.5.1
Find optimal clusterings and optimal hierarchical clusterings.
Requires Python: >=3.10
Keywords: clustering, k-means, k-median, optimization, algorithms

![PyPI - Version](https://img.shields.io/pypi/v/exact-clustering)

Low-effort way of calling the rust-crate [`exact-clustering`](https://github.com/lumi-a/exact-clustering) from Python. 

```sh
pip install exact-clustering
```

Consult [docs.rs](https://docs.rs/exact-clustering) for more extensive documentation.

```py
from exact_clustering import *

weighted_points = [
    (1.0, [0, 0]),
    (1.0, [1, 0]),
    (3.0, [0, 2]),
]

print(
    weighted_continuous_kmeans_price_of_hierarchy(
        weighted_points
    )
)
# 1.0
```

View provided methods via `help(exact_clustering)` in the python-repl or take a look at `exact_clustering.pyi`. At time of writing, they are:

```py
class KMeans:
    def __new__(cls, data: Sequence[Sequence[float]]) -> KMeans: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class KMedianL1:
    def __new__(cls, data: Sequence[Sequence[float]]) -> KMedianL1: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class KMedianL2:
    def __new__(cls, data: Sequence[Sequence[float]]) -> KMedianL2: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class KMedianL2Squared:
    def __new__(cls, data: Sequence[Sequence[float]]) -> KMedianL2Squared: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class UnweightedKMedianL1:
    def __new__(cls, data: Sequence[tuple[float, Sequence[float]]]) -> UnweightedKMedianL1: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class UnweightedKMedianL2:
    def __new__(cls, data: Sequence[tuple[float, Sequence[float]]]) -> UnweightedKMedianL2: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class UnweightedKMedianL2Squared:
    def __new__(cls, data: Sequence[tuple[float, Sequence[float]]]) -> UnweightedKMedianL2Squared: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...

class WeightedKMeans:
    def __new__(cls, data: Sequence[tuple[float, Sequence[float]]]) -> WeightedKMeans: ...
    def price_of_hierarchy(self) -> float: ...
    def price_of_greedy(self) -> float: ...
```

## License

Licensed under either of

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.


## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
adk-mongodb-session 1.0.9
A project to integrate together Agent Development Kit (ADK) with MongoDB session management as backend storage.
Requires Python: >=3.11

# MongoDB Session Service for [Google ADK](https://google.github.io/adk-docs/) (Agent Development Kit)

[![PyPI version](https://badge.fury.io/py/adk-mongodb-session.svg)](https://badge.fury.io/py/adk-mongodb-session)
[![Python Package CI](https://github.com/SergeySetti/adk-mongodb-session/actions/workflows/python-package.yml/badge.svg)](https://github.com/SergeySetti/adk-mongodb-session/actions/workflows/python-package.yml)

A session management library for the Google ADK framework that uses MongoDB as a backend.

This package provides a `MongodbSessionService` that implements the `google.adk.sessions.base_session_service.BaseSessionService` abstract base class. It allows you to store and manage session state in a MongoDB database, fully replicating the three-tiered state management (`app`, `user`, and `session`) found in the core ADK session services.

## Installation

You can install the package from PyPI:

```bash
pip install adk-mongodb-session
```

## Usage

First, instantiate the `MongodbSessionService` with your MongoDB connection details.

```python
import asyncio
from adk_mongodb_session.mongodb.sessions import MongodbSessionService

# Initialize the service
session_service = MongodbSessionService(
    db_url="mongodb://localhost:27017/",
    database="my_adk_agent_db",
    collection_prefix="sessions"  # This will create sessions_sessions, sessions_app_states, etc.
)

# ... and then use it in your async context

example_session = await session_service.create_session(
    app_name="my_app",
    user_id="example_user",
    state={"initial_key": "initial_value"} # State can be initialized
)
```


## Running Tests

For development, clone the repository and install it in editable mode with the testing dependencies:

```bash
git clone https://github.com/your-username/adk-mongodb-session.git
cd adk-mongodb-session
pip install -e ".[test]"
```

Then, run the tests using `unittest`:

```bash
python -m unittest discover tests
```

## Contributing

Contributions are welcome! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) file for details on how to report bugs, suggest enhancements, and submit pull requests.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
pm4mkb 0.1.4
Library that is intended to operate with various process mining tasks.

![](https://github.com/pm291097/pm4mkb/blob/main/imgs/Logo.png?raw=true)

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pm4mkb)](https://pypi.org/project/pm4mkb)
[![PyPI - Version](https://img.shields.io/pypi/v/pm4mkb)](https://pypi.org/project/pm4mkb)
![PyPI - Downloads](https://img.shields.io/pypi/dm/pm4mkb)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
### [Documentation](https://process-mining-mkb.readthedocs.io/en/latest/)  |  [Installation](#installation) | [Quick start](#quick-start)
# MKBProcessMining (PM4MKB) – Process Mining Python framework
PM4MKB is an open-source Python library for conducting a comprehensive analysis of business processes with the use of process mining and machine learning techniques. By implementing this tool, objective and deep insights into the process on all levels can be revealed. These insights are then used to detect problems such as bottlenecks and deviations and identify potential opportunities for process improvement and optimization.

Authors: Process Mining for MKB Team.

# Installation

To install PM4MKB framework on your machine from PyPI:
```bash
pip install pm4mkb
```
To install from sources:
```bash
git clone https://github.com/pm291097/pm4mkb.git

cd MKB_Process_Mining
pip install .
```

Additionally, you have to install graphviz executables and add the path to the executables to PATH variable:  
https://graphviz.org/download/

# Quick start

There are some steps for quick start for your process log analysis:
* Create a DataHolder object:
```python
from pm4mkb import SuccessInputs, DurationUnits

path = "example_data.xlsx"
data_holder = DataHolder(
    data=path,
    col_case="id",
    col_stage="action",
    col_start_time="start_time",
    col_end_time="end_time",
    col_user="user_id",
    col_text="text",
    success_inputs=SuccessInputs(entries={"Подписание документов ", "Принято"}),
)

data_holder.data.head()
```
* Apply AutoInsights:
```python
from pm4mkb.autoinsights import AutoInsights

auto_insights = AutoInsights(data_holder, successful_stage="Принято")
auto_insights.apply()
```

# License
This project is released under the [MIT License](https://github.com/pm291097/pm4mkb/blob/main/LICENSE).
surfquake 0.1.7
SurfQuake Core
Requires Python: >=3.9

[![Python application](https://github.com/rcabdia/SurfQuakeCore/actions/workflows/python-app.yml/badge.svg)](https://github.com/rcabdia/SurfQuakeCore/actions/workflows/python-app.yml)
<img src="surfquakecore/resources/logo/surfQuake.png" width="600">

# SurfQuakeCore

SurfQuake Core Library has been designed to streamline the workflow of estimating seismic source parameters. Comprehensive set of toolboxes automates the determination of arrival times, event locations, compute earthquake source
parameters (seismic moment, corner frequency, radiated energy, source size,
static stress drop, apparent stress) from the inversion of P-wave and S-wave and focal mechanism from moment tensor inversion.


## Citation

Cabieces, R., Junqueira, T. C., and Relinque, J.: SurfQuake (SQ): A new Python toolbox for the workflow process of seismic sources, EGU General Assembly 2024, Vienna, Austria, 14–19 Apr 2024, EGU24-2816, https://doi.org/10.5194/egusphere-egu24-2816, 2024.

Roberto Cabieces, Andrés Olivar‐Castaño, Thiago C. Junqueira, Jesús Relinque, Luis Fernandez‐Prieto, Jiří Vackár, Boris Rösler, Jaime Barco, Antonio Pazos, Luz García‐Martínez; Integrated Seismic Program (ISP): A New Python GUI‐Based Software for Earthquake Seismology and Seismic Signal Processing. Seismological Research Letters 2022;; 93 (3): 1895–1908. doi: https://doi.org/10.1785/0220210205