semvec/pypi-packages huggingface dataset:
clonai 0.0.1
Python bindings for the DNA engineering library poly
License: MIT
Requires Python: <4.0,>=3.12

# poly_py

python bindings for Poly

These bindings are experimental and generated directly from poly's Go implementation

`pip install clonai`
`poetry add clonai`

```python

from poly import checks

isDNA? = checks.IsDNA("ACTC")

print(isDNA?)
```

If there's enough interest I'll

1. Refactor poly to make all or most features fully exportable to python
2. Solidify build pipeline so that other folk can easily write a deploy go packages to extend python
3. Release statically generated doc site for python bindings via readthedocs
4. Beg the current holder of the `poly` namespace on pypi to let this project use it.
easy-git-cli 0.3.0
A CLI tool to simplify Git workflows
License: MIT
Requires Python: <4.0,>=3.12

# Easy-Git CLI Tool

**Easy-Git** is a command-line tool designed to simplify and streamline common Git workflows, making it easier and faster to interact with Git repositories. This tool is particularly useful for developers who want to automate repetitive tasks like staging files, committing changes, and pushing to remote repositories.

Currently, **Easy-Git** includes the following features:
- **Quick Commit**: A streamlined process for staging, committing, and pushing changes to the repository.
- **Shortcuts for Commands**: You can use both `quick-commit` and `c` to trigger the same functionality.
- More features coming soon!

> **Note**: This project is a work in progress and will be extended with more tools and functionalities over time. Stay tuned for more features!


## 🚀 Installation

### Prerequisites
Ensure that you have **Python** installed.

### Install the Tool

The tool is available on PyPI, so you can install it using `pip`:

```bash
pip install easy-git
```
Or `poetry`:

```bash
poetry add easy-git
```

## ⚙️ Usage

Once installed, you can use the tool directly from the command line.

### Available Commands

- **`quick-commit`**: Perform the add-commit-push cycle.
- **`c`**: Alias for the `quick-commit` command.

### Example Usage

1. **Stage and commit files**:

   ```bash
   easy-git quick-commit
   ```

   Or use the shortcut:

   ```bash
   easy-git c
   ```


## 🚧 Work in Progress

This project is still in progress, and new features will be added over time. Current functionalities include the `quick-commit` cycle, but more tools and features will be added in the future.

Stay tuned for updates!


## 📝 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
simplegrad 0.0.2
Automatic differentiation library for basic arithmetic operations
License: MIT
Requires Python: >=3.6

# SimpleGrad

SimpleGrad is a lightweight automatic differentiation library written in C++ with Python bindings.

### Compatible Operating Systems:
- Linux (x86_64 architecture only)

## Installation
```bash
pip install simplegrad
```

## Features

- Multi-layer perceptron (MLP) which can be used for regression and classification tasks
- Supports basic arithmetic operations
- Lightweight and easy to use
- Gradient computation
- Backpropagation
- Numpy compatibility


## Usage

Here's a quick example of how to use MLP in SimpleGrad:

```python
from simplegrad import MLP, Node
from sklearn import datasets

# Define the model
X, y = datasets.make_classification(
        n_samples=1000,
        n_features=10,
        n_classes=2,
        random_state=42,  # for reproducibility
    )
lr = 0.01
batch_size = 16
epochs = 10

# Define the model
model = MLP(
    10, [16, 1]
)  # 2 input nodes, 2 hidden layers with arbitrary sizes, 1 output node

# Training data
n_batches = (len(X) + batch_size - 1) // batch_size  # Ceiling division

for epoch in range(epochs):
    epoch_loss = 0.0
    for i in range(0, len(X), batch_size):
        batch_X = X[i : i + batch_size]
        batch_y = y[i : i + batch_size]
        current_batch_size = len(batch_X)  # Handle last batch

        batch_loss = 0.0
        #model.zero_grad()  # gradients are automatically reset after step function

        # Accumulate gradients over batch
        for x, y_true in zip(batch_X, batch_y):
            y_hat = model(x)[0]
            y_true = Node(y_true)
            loss = (y_hat - y_true) ** 2
            loss = loss * (1.0 / current_batch_size)  # Normalize loss
            batch_loss += loss.data()
            loss.backward()

        model.step(lr)  # Update weights using accumulated gradients
        del loss, y_hat, y_true  # Clean up
        epoch_loss += batch_loss

    # Average loss over all batches
    print(f"Epoch {epoch+1}, Average Loss: {epoch_loss/n_batches:.3f}")
```
babelon 0.3.4
babelon
License: MIT
Requires Python: <4.0,>=3.11

[![DOI](https://zenodo.org/badge/369423393.svg)](https://zenodo.org/badge/latestdoi/369423393)

# Babelon - A simple standard for managing ontology translations and language profiles

Editors:
- @matentzn
- @LLTommy
- @mellybelly
- @drseb
- Anyone that wants to be on here.

[Provisional documentation here.](https://monarch-initiative.github.io/babelon/)

Babelon is simple standard for managing ontology translations and language profiles. Profiles are managed a simple TSV files, for example:

| source                                | source_version                                               | source_language | translation_language | subject_id | predicate_id     | source_value       | translation_value   | translator                            | translation_date | translation_confidence | translation_precision | translation_type |
|---------------------------------------|--------------------------------------------------------------|-----------------|----------------------|------------|------------------|--------------------|---------------------|---------------------------------------|------------------|------------------------|-----------------------|------------------|
| http://purl.obolibrary.org/obo/hp.owl | http://purl.obolibrary.org/obo/hp/releases/2021-04-13/hp.owl | en              | de                   | HP:0001945 | rdfs:label       | Fever              | Fieber              | https://orcid.org/0000-0002-1373-XXXX |       2021-05-21 |                   0.95 | exact                 | HumanCurated     |
| http://purl.obolibrary.org/obo/hp.owl | http://purl.obolibrary.org/obo/hp/releases/2021-04-13/hp.owl | en              | de                   | HP:0002615 | oio:exactSynonym | Low blood pressure | Niedriger Blutdruck | https://orcid.org/0000-0002-1373-XXXX |       2021-05-21 |                    0.9 | exact                 | HumanCurated     |

The goal of Babelon is to capture the minimum data required to enable the following use cases:

- Translate a profile into RDF to enable seamless integration of alternative language alongside the primary ones.
- Support all properties for translation, including labels, synonyms and definitions.
- Capture important metadata such as confidence and precision of translation.
- Enable cross-language editing. For example:
  - Notify language profile maintainers of new terms or changed labels
  - Notify the core ontology teams of changes to translations, with a potential to suggest updating ones own annotations or adding new synonyms.


As a first use case for the format, we see to capture the French language translations of the Human Phenotype Ontology by the Orphanet team and use them to provide versioned language profiles of HPO.

### Editors

```
# in new environment
pip install poetry
poetry install
make translations
```
# Acknowledgements

This [cookiecutter](https://cookiecutter.readthedocs.io/en/stable/README.html) project was developed from the [monarch-project-template](https://github.com/monarch-initiative/monarch-project-template) template and will be kept up-to-date using [cruft](https://cruft.github.io/cruft/).
danak 0.0.1
danak - Lightweight Python ORM
License: MIT
Requires Python: >=3.11.0


# Danak - Lightweight Python ORM

## 🚀 Project Overview

Danak is a simple and flexible Object-Relational Mapping (ORM) library for Python. This library simplifies database interactions and provides an intuitive interface for Python developers.

## ✨ Key Features

- **Easy Model Creation**: Quickly and effortlessly create database models
- **Migration Management**: Convenient migration mechanism for managing database structures
- **Flexible Field Handling**: Support for various data field types
- **Minimal Configuration**: Quick setup with minimal configuration required
- **Convenient Sorting and Filtering**: Easy data sorting and filtering capabilities

## 🛠️ Technologies

- Programming Language: Python
- ORM Type: Lightweight
- Database Compatibility: Works with SQL databases like SQLite, PostgreSQL, MySQL

## 📦 Installation

```bash
pip install danak
```

## 🚦 Basic Usage Examples

### Creating a Model
```python
from danak import Model, Field

class User(Model):
    id = Field(int, primary_key=True)
    name = Field(str)
    email = Field(str, unique=True)
```

### Creating Migrations
```python
from danak import create_migrations

create_migrations(User)
```

## 🤝 Contributing

Contributions are welcome! Feel free to open pull requests or issues.

## 📄 License

MIT License

## 📬 Contact

For questions and suggestions, please use the GitHub issues section.