semvec/pypi-packages huggingface dataset:
datateer-cli 1.1.0
Datateer CLI to support devops and infrastructure
Requires Python: <4.0,>=3.9

# Scripts for devops

- [Scripts for devops](#scripts-for-devops)
  - [Development](#development)
    - [Setup](#setup)
  - [Fixing Semantic Release](#fixing-semantic-release)
    - [Disclaimer](#disclaimer)
    - [Steps](#steps)

## Development

### Setup
1. poetry install
2. poetry shell

## Fixing Semantic Release

* [Source](https://github.com/relekang/python-semantic-release)
* [Action](https://python-semantic-release.readthedocs.io/en/latest/automatic-releases/github-actions.html)
* [Documentation](https://python-semantic-release.readthedocs.io/en/latest/#getting-started)
* [Configuration](https://python-semantic-release.readthedocs.io/en/latest/configuration.html)
  * These are being stored in the file `pyproject.toml` and its `tools.semantic_release` section

This is to resolve issues cuased by manually creating a version tag in conflict with what the CI process wants to create.

### Disclaimer

The below needs to be completed as an administrator of the git repo

This process is required because the semantic release action being used requires matching information

### Steps

1) Pull down the current main branch to your local
   1) Ensure that your git status shows no changes
2) Record the current tag without the `v` prefix
3) Update files:
   1) datateer_cli/\_\_init__.py
      1) set `__version__` to the currnet version
   2) CHANGELOG.md
      1) follow the format seen in the file adding the current version
4) git add .
5) git commit -m "<current version>"
   1) ensure that there isn't any other text other than the version for the commit message
6) git push

Now you have brought the repo back into a state where the semantic release can work as expected
Complicator 0.2.0
Estimate thermodynamic properties of aqueous metal complexes with monovalent ligands.
Requires Python: >=3.10

# The Complicator

Code Authors: Grayson Boyer, Everett Shock
Data Compilers: GEOPIG Lab, Apar Prasad

This is a Python package for estimating standard state thermodynamic properties and Helgeson-Kirkham-Flowers (HKF) equation of state parameters for aqueous metal complexes with monovalent ligands using published methods from [Sverjensky et al. (1997)](https://doi.org/10.1016/s0016-7037(97)00009-4) and [Shock et al. (1997)](https://doi.org/10.1016/S0016-7037(96)00339-0)

## Installation

This package can be installed through PyPI with:
`pip install Complicator`

## Usage

The best way to learn about the Complicator is through the WORM Portal ([worm-portal.asu.edu](worm-portal.asu.edu)). Check out Jupyter notebook demo 4-2-1 in the WORM Library that is available when you log in.

What follows is a brief example of how the Complicator can be used.

Supply a dataframe containing names of metals, ligands, stability constants for the first through fourth association at 25 °C, and optionally, standard state entropies of association for the first through fourth association complex. An example is assigned to the variable `df_input` in the example below.

```
import pandas as pd
from Complicator import complicate

df_input = pd.DataFrame({
        "Metal":["Ag+", "Al+3"],
        "Ligand":["OH-", "OH-"],
        "BETA_1":[2, 9.03], # stability constant for the first association complex
        "BETA_2":[3.97, 17.6], # second stability constant
        "BETA_3":[float('NaN'), 26.4], # third stability constant
        "BETA_4":[float('NaN'), 33.8], # fourth stability constant
        "Sass_1":[float('NaN'), 36.5], # entropy of association for the first complex (cal/mol/K)
        })

df_out, _, _, _ = complicate(df_in=df_input)

df_out
```

The output is a dataframe containing estimated thermodynamic properties, parameters for the revised Helgeson Kirkham Flowers (HKF) equation of state, and more. [The format of the output is explained in more detail here](https://worm-portal.asu.edu/docs/database/). This Water-Organic-Rock-Microbe (WORM) database format is designed to be compatible with the free and open source online geochemical modeling platform [WORM Portal](https://worm-portal.asu.edu/). Estimated thermodynamic properties of complexes from the Complicator can be used in conjunction with the rest of the WORM database to:
- calculate properties of reactions and create activity or predominance diagrams.
- expand the number of aqueous complexes available in geochemical speciation (equilibration) and mass transfer calculations.
ed-core 0.4.6
EasyDrop auth model Package
Requires Python: >=3.12
Keywords: ed_core, pypi, package

# py
Template class for python backend servers.

## Features
- [x] RabbitMQ
- [x] Logging
- [X] Generic Helpers
- [ ] Kafka
- [ ] Redis
- [x] API: RequestHandler, FastAPI
- [x] Dockerfile
- [x] Makefile
- [x] CI/CD
- [x] Entry point file
- [x] Configfile / Configuration
- [x] Websockets

## Usage
The project's dependencies are managed by `poetry`. You can install the dependencies with:
```bash
poetry install
```

`package.py` is the entry point file.

### Running the package
You can run the package inside of a virtual environment:
```bash
poetry shell
make run
```

or with `docker`:
```bash
make run_docker
```


### Running the tests
You can run the tests inside of a virtual environment:
```bash
poetry shell
make test
```
or with `docker`:
```bash
make test_docker
```
duots 0.1.10
Composable timeseries feature extraction for paired signals.
Requires Python: >=3.11

# duots

**duots** is a lightweight Python package for calculating features from paired time series signals — like those collected from symmetrical body parts (e.g., left and right wrists). It provides a composable, lazy, and efficient pipeline to build complex signal analysis routines.

---

## Features
-  **Composable feature pipelines** using functional programming
-  Modular primitives: segmentation, transformation, timeseries ops, value aggregation
-  Efficient via `functools.lru_cache` (minimizes redundant computation)
-  **Minimal dependencies**: uses only `scipy` (and optionally [sampen-gpu](https://github.com/4d30/sampen)) 
-  Designed for **paired signals** (e.g., `(left, right)` or `(x, y)`)
-  Easy to extend, debug, and test

## Design Philosophy
- **Composable**: Build powerful feature extractors from simple, small functions.
- **Efficient**: Shared operations are cached; performance scales with reuse.
- **Minimal**: Only `scipy` is used for FFT, skew, and kurtosis; avoids heavy dependencies.

## 📦 Installation
### From PyPI  --  [duots](https://pypi.org/project/duots/)
```bash
pip install duots
```
### From Source
```bash
git clone https://github.com/4d30/duots.git
cd duots
pip install .
```

## Example Usage
```python
from duots import generate, compose

# Create a pair of signals, e.g., (left, right)
# They must be tuples, of the same length, without NaNs
sig_a = tuple(range(1, 100))
sig_b = tuple(range(1, 100))
signal_pair = (sig_a, sig_b,)

# Calculate values for each process
for proc in generate.processes():
    names, funcs = zip(*proc)
    name = compose.descriptors(names)
    composed_function = compose.functions(funcs)
    value = composed_function(signal_pair)
    print(f"{name}: {value}")
```