semvec/pypi-packages huggingface dataset:
taipy-templates 4.1.1
An open-source package holding Taipy application templates.
Requires Python: <3.13,>=3.9
Keywords: taipy, taipy-templates

# Taipy Templates

## License

Copyright 2021-2024 Avaiga Private Limited

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of the License at
[http://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)

Unless required by applicable law or agreed to in writing, software distributed under the
License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
either express or implied. See the License for the specific language governing permissions
and limitations under the License.

## What is Taipy templates

Taipy is a Python library for creating Business Applications. More information on our
[website](https://www.taipy.io). Taipy is split into multiple packages including *taipy-templates*
to let users install the minimum they need.

Taipy templates is a repository that contains application templates created and
maintained by Taipy. It helps users getting started with a simple and ready-to-go application.

To create a Taipy application using this template, first you need to install Taipy (> 2.2).
Then from a terminal, run the following command.
```bash
taipy create
```
or
```bash
taipy create --application "default"
```

After providing necessary information, your new application is created in the current
working directory.

## Installation

The latest stable version of *taipy-templates* is available through *pip*:
```bash
pip install taipy-templates
```

You can install the development version of *taipy-templates* with *pip* and *git* via the taipy repository:
```bash
pip install git+https://git@github.com/Avaiga/taipy
```

This command installs the development version of *taipy* package in the Python environment with all
its dependencies, including the *taipy-templates* package.

If you need the source code for *taipy-templates* on your system so you can see how things are done or
maybe participate in the improvement of the packages, you can clone the GitHub repository:

```bash
git clone https://github.com/Avaiga/taipy.git
```

This creates the 'taipy' directory holding all the package's source code, and the 'taipy-templates'
source code is in the 'taipy/templates' directory.
resend 2.22.0
Resend Python SDK
Requires Python: >=3.7
Keywords: email, email platform

# Resend Python SDK

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
![Build](https://github.com/drish/resend-py/actions/workflows/ci.yaml/badge.svg)
[![codecov](https://codecov.io/gh/drish/resend-py/branch/main/graph/badge.svg?token=GGD39PPFM0)](https://codecov.io/gh/drish/resend-py)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![PyPI](https://img.shields.io/pypi/v/resend)](https://pypi.org/project/resend/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/resend)](https://pypi.org/project/resend)

---

## Installation

To install Resend Python SDK, simply execute the following command in a terminal:

```
pip install resend
```

## Setup

First, you need to get an API key, which is available in the [Resend Dashboard](https://resend.com).

```py
import resend
import os

resend.api_key = "re_yourkey"
```

## Example

You can get an overview about all parameters in the [Send Email](https://resend.com/docs/api-reference/emails/send-email) API reference.

```py
import os
import resend

resend.api_key = "re_yourkey"

params: resend.Emails.SendParams = {
    "from": "onboarding@resend.dev",
    "to": ["delivered@resend.dev"],
    "subject": "hi",
    "html": "<strong>hello, world!</strong>",
    "reply_to": "to@gmail.com",
    "bcc": "bcc@resend.dev",
    "cc": ["cc@resend.dev"],
    "tags": [
        {"name": "tag1", "value": "tagvalue1"},
        {"name": "tag2", "value": "tagvalue2"},
    ],
}

email: resend.Emails.SendResponse = resend.Emails.send(params)
print(email)
```
spbessax 0.1.4
spherical Bessel functions for JAX
Requires Python: >=3.7
Keywords: Spherical Bessel functions, Bessel, JAX

# spbessax

This repository contains a JAX implementation of spherical bessel functions that
is fully compatible with jax.jit and jax.grad. It is based on the implementation
by @sousaw in [NeuralIL](https://github.com/Madsen-s-research-group/neuralil-public-releases).

Additional tests have been included to confirm this implementation works also for complex valued arguments.

The package can be installed from [PyPi](https://pypi.org/project/spbessax/) using pip:

`pip install psbessax`
taipy-core 4.1.1
A Python library to build powerful and customized data-driven back-end applications.
Requires Python: <3.13,>=3.9
Keywords: taipy, taipy-core

# Taipy Core

## License

Copyright 2021-2024 Avaiga Private Limited

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of the License at
[http://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)

Unless required by applicable law or agreed to in writing, software distributed under the
License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
either express or implied. See the License for the specific language governing permissions
and limitations under the License.

## What is Taipy Core

Taipy is a Python library for creating Business Applications. More information on our
[website](https://www.taipy.io). The Taipy core package includes business-oriented features such as Data Integration and Management, Scenario Management, What-if analysis, and Version management.

## Installation

The latest stable version of *taipy-core* is available through *pip*:
```bash
pip install taipy-core
```

You can install the development version of *taipy-core* with *pip* and *git* via the taipy repository:
```bash
pip install git+https://git@github.com/Avaiga/taipy
```

This command installs the development version of *taipy* package in the Python environment with all
its dependencies, including the *taipy-core* package.

If you need the source code for *taipy-core* on your system so you can see how things are done or
maybe participate in the improvement of the packages, you can clone the GitHub repository:

```bash
git clone https://github.com/Avaiga/taipy.git
```

This creates the 'taipy' directory holding all the package's source code, and the 'taipy-core'
source code is in the 'taipy/core' directory.
energizer 0.1.4
A lightweight deep learning library for Apple's Neural Engine.
Requires Python: >=3.10
Keywords: deep-learning, neural-engine, machine-learning, mlx, apple

Energizer (formerly `energizer`) – custom PyTorch-like library for the Neural Engine

## Need to Implement:

### A. Essential Layers:

- [x] Batch Normalization - Critical for stable training (BatchNorm1d, BatchNorm2d)
- [x] Dropout - For regularization
- [x] Pooling layers (MaxPool2d, AvgPool2d)
- [x] Flatten layer - To convert conv outputs to linear inputs
- [x] Residual blocks - For deeper networks

### B. Activation Functions:

- [x] Sigmoid - For binary classification
- [x] Tanh - For value estimation (-1 to 1)
- [x] LeakyReLU - Better than ReLU in some cases
- [ ] Softmax - For move probability distribution

### C. Loss Functions:

- [x] MSE Loss - For value prediction
- [x] CrossEntropy Loss - For move prediction
- [ ] Huber Loss - More robust than MSE
- [ ] Custom chess loss - Combine policy and value loss
cornflow-client 1.3.1rc1
Client to connect to a cornflow server
Requires Python: >=3.10

cornflow client
================

The aim of this repository is to have a client to use to connect to a deployed cornflow webserver

Requirements
~~~~~~~~~~~~

* python >= 3.8

Install cornflow-client
~~~~~~~~~~~~~~~~~~~~~~~~

To install the package do::

    python3 -m pip install cornflow-client

Use cornflow-client
~~~~~~~~~~~~~~~~~~~~

To use, first you have to import the package::

    from cornflow_client import CornFlow

Then you have to start up the client and login or sing up::

    client = CornFlow(url="URL_TO_THE_WEB_SERVER")
    client.sign_up(username, email, password)
    client.login(username, password)

And then finally you can use the cornflow webserver and start solving problems::

    instance_id = client.create_instance(data)
    execution_id = client.create_execution(instance_id, execution_config)
    status = client.get_status(execution_id)
    results = client.get_results(execution_id)
taipy-common 4.1.1
A Taipy package dedicated to provide common data structures, types, classes and functions.
Requires Python: <3.13,>=3.9
Keywords: taipy, taipy-common

# Taipy Config

## License

Copyright 2021-2024 Avaiga Private Limited

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of the License at
[http://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)

Unless required by applicable law or agreed to in writing, software distributed under the
License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
either express or implied. See the License for the specific language governing permissions
and limitations under the License.

## What is Taipy Config

Taipy is a Python library for creating Business Applications. More information on our
[website](https://www.taipy.io). Taipy is split into multiple packages including *taipy-common*
to let users install the minimum they need.

Taipy Config is a package designed to help users configure their Taipy application.

## Installation

The latest stable version of *taipy-common* is available through *pip*:
```bash
pip install taipy-common
```

You can install the development version of *taipy-common* with *pip* and *git* via the taipy repository:
```bash
pip install git+https://git@github.com/Avaiga/taipy
```

This command installs the development version of *taipy* package in the Python environment with all
its dependencies, including the *taipy-common* package.

If you need the source code for *taipy-common* on your system so you can see how things are done or
maybe participate in the improvement of the packages, you can clone the GitHub repository:

```bash
git clone https://github.com/Avaiga/taipy.git
```

This creates the 'taipy' directory holding all the package's source code, and the 'taipy-common'
source code is in the 'taipy/common' directory.
open-earable-python 0.0.2
Reader and utilities for multi-sensor OpenEarable recordings.
Requires Python: >=3.9
Keywords: openearable, earable, sensors, imu, ppg, audio, wearables, .oe

# Open Earable Python

Python toolkit for parsing and analyzing multi-sensor OpenEarable recordings.

## Installation

```bash
pip install open-earable-python
```

For local development:

```bash
git clone https://github.com/OpenEarable/open-earable-python.git
cd open-earable-python
python -m venv .venv
source .venv/bin/activate
pip install -e .
```

## Quick Example

```python
from open_earable_python import SensorDataset

dataset = SensorDataset("recording.oe")

# Combined time-indexed DataFrame of all parsed sensors
df = dataset.get_dataframe()

# Per-sensor views
imu_df = dataset.imu.df
ppg_red = dataset.ppg["ppg.red"]
audio_df = dataset.get_audio_dataframe()
```

## Documentation

- [Documentation index](docs/README.md)
- [Getting started](docs/getting-started.md)
- [Data model and sensor channels](docs/data-model.md)
- [API reference](docs/api-reference.md)

## License

MIT. See `LICENSE`.
naturally-linux 0.1.5
Natural-language to Linux shell command AI CLI tool with safety checks
Requires Python: >=3.13

# Naturally Linux

Naturally Linux is a command-line tool that turns natural-language requests into safe, reviewable Linux shell commands. It shows you the proposed command, explains what it does, and runs it only after confirmation.

## Features

- Natural-language → shell command generation
- Command preview and explanation
- Safety checks before execution
- Confirmation before running commands

## Install (recommended)

Install the UV package manager, then install the CLI system-wide:

```
curl -LsSf https://astral.sh/uv/install.sh | sh
uv tool install naturally-linux
```

Alternative (pip):

```
pip install naturally-linux
```

## Setup

Store your Groq API key (recommended):

```
naturally-linux config set-key YOUR_GROQ_API_KEY
```

Or set it via environment variable:

```
export GROQ_API_KEY="your-key"
```

## Usage

Generate and run a command:

```
naturally-linux "list files larger than 10MB"
```

Preview with explanation only:

```
naturally-linux "list files larger than 10MB" --dry-run
```

Set a timeout (seconds):

```
naturally-linux "scan logs" --timeout 10
```

Manage API key:

```
naturally-linux config show
naturally-linux config delete
```

## License

MIT
quality-toolkit 2.6.0
Toolkit for the quality in order to help writing tests
Requires Python: <3.14,>=3.10
Keywords: Quality, Toolkit, Testing

# Quality-Toolkit

Toolkit for the quality in order to help writing tests

## Contribution

Clone the project

```bash
git clone https://github.com/veepee-oss/quality-toolkit quality-toolkit
cd quality-toolkit
```

## Installation in local

```bash
make install
```

## Installation in a project

Edit the project's requirements.txt and add the line :

```txt
quality-toolkit
```

and finish by install the project dependencies :

```bash
pip3 install -r requirements.txt
```

## How to use the lib

See the list of available components :

* [docstring](docs/docstrings.md)