semvec/pypi-packages huggingface dataset:
poetry-pre-commit-plugin 0.2.2
Poetry plugin for automatically installing pre-commit hook when it is added to a project
Requires Python: <4.0,>=3.7

# Poetry pre-commit Plugin

[![PyPI](https://img.shields.io/pypi/v/poetry-pre-commit-plugin?color=blue)](https://pypi.org/project/poetry-pre-commit-plugin/)

A [Poetry](https://python-poetry.org/) plugin for automatically installing git
pre-commit hooks whenever `pre-commit` is specified as a dependency of the
project.

## Motivation

Personally I find that running `pre-commit install` every time I start working
on a new repository is very easy to forget - there have been numerous occasions
where I'd forget this step, commit some changes only to be surprised later on
by failing CI checks 😅 This plugin aims to solve this issue by doing
this small step for me automatically behind the scenes.

## Installation

The plugin requires Poetry version `1.2.0b1` or above. Since this is still a
pre-release version, you have to specify it explicitly when installing:

```
curl -sSL https://install.python-poetry.org | python3.9 - --version 1.2.0b3
```

Once a valid version of Poetry is set up, you can install the plugin like so:

```
poetry self add poetry-pre-commit-plugin
```

For more in-depth information, please refer to
[Poetry's docs](https://python-poetry.org/docs/master/plugins/).

## Usage

There's no way to use this plugin explicitly - it will work behind the scenes
after you run either `poetry install` or `poetry add`. In either of those cases,
the plugin will check the following conditions:

1. Is the project inside a git repository?
2. Is `pre-commit` listed as a dependency of the project (or, in the case of
   `poetry add` - was it just added)?
3. Has the pre-commit hook **not** been activated yet (i.e. the file
   `.git/hooks/pre-commit` does not exist)?

If all conditions are met, the plugin will run `pre-commit install` for you.
netbox-paas 0.3.6
Enhances NetBox on CloudMyDC's PaaS with advanced management and control features.
Keywords: netbox, netbox-plugin

# NetBox PaaS

[NetBox PaaS](https://github.com/Onemind-Services-LLC/netbox-paas) is a specialized plugin tailored for
NetBox, offering enhanced functionality for users on
[CloudMyDC PaaS](https://app.xapp.cloudmydc.com/). This plugin simplifies the management of
various NetBox components and infrastructure, streamlining processes and offering a more integrated experience.

NetBox PaaS, developed and maintained by [Onemind Services LLC](https://onemindservices.com/), introduces an
exclusive plugin store for NetBox. It caters to users with a diverse range of both free and paid plugins, enhancing the
NetBox experience.

## Features

NetBox PaaS integrates several key features:

- **Management of NetBox Settings**: Control settings for Database (DB), Redis, System, and security and much more.
- **Infrastructure Log Viewing**: Access and monitor logs from different nodes within the infrastructure.
- **Node Restart Capabilities**: Remotely restart nodes within the infrastructure.
- **Database Backup and Restoration**: Manage and restore DB backups.
- **Plugin Management**: Install, uninstall, and configure other NetBox plugins.

## Compatibility

| NetBox Version | Plugin Version |
|----------------|----------------|
| v3.5.x         | v0.0.x         |
| v3.6.x         | v0.2.x         |
| v3.7.x         | v0.3.x         |

# Installation

For updates, visit [NetBox PaaS releases](https://github.com/Onemind-Services-LLC/netbox-paas/releases).

## Support

For support, questions, or feedback, please file an issue on our [GitHub issue tracker](https://github.com/Onemind-Services-LLC/netbox-paas/issues).

## Contributing

Contributions to NetBox PaaS are welcome! If you'd like to contribute, please fork the repository and submit a
pull request. For more detailed information, refer to our contributing guidelines in the repository.
fennel-ai 1.5.80
The modern realtime feature engineering platform
Requires Python: <4.0,>=3.9

# Welcome to Fennel

## The modern realtime feature engineering platform

---

Fennel is a modern realtime feature engineering platform written in Rust and this repo contains the Python client to talk to the server. 

Quick Links:
- [Documentation](https://docs.fennel.ai/)
- [Fennel Website](https://fennel.ai/)
- [Main Concepts Behind Fennel](https://docs.fennel.ai/concepts/introduction/)
- [Quickstart Tutorial](https://docs.fennel.ai/getting-started/quickstart/)
paic-patterns 0.1.53
Principled AI Coding Patterns for large-scale, max-compute, low-error engineering in the GenAI Age.
Requires Python: <3.13,>=3.9

# PAIC Patterns

Principled AI Coding Patterns for large-scale, max-compute, low-error engineering in the GenAI Age.

> **WARNING:** Do not install using pip. This is a private, members-only tool. You will not have access. See [this link](https://agenticengineer.com/principled-ai-coding) to gain access.

![PAIC Patterns](https://firebasestorage.googleapis.com/v0/b/agentic-engineer.appspot.com/o/paicc%2Fpublic-images%2Fpaic-patterns-members-only.jpg?alt=media&token=94b4d1b6-3d5c-4163-93d3-81e6835629b9)

## What is PAIC Patterns?

### AI Coding at Scale
PAIC Patterns is a light weight, plan based AI Coding tool that's designed to SCALE YOUR IMPACT with LARGE SCALE, FULL FEATURE, PRECISE AI Coding. This bonus, members only, tool embeds the principles you've learned in the Principled AI Coding course into a suite of easy to use patterns.

### Scale Your Compute - Scale Your Impact
Most AI Coding tools are limited by their 'one prompt at a time', iterative approach. PAIC Patterns let's you scale your compute, and scale your impact by giving you patterns to run not just one prompt at a time, but 2, 5, 10, 20+ prompts in one shot. Here's how it works:

1. (CREATE) Create a new spec
2. (PLAN) Update the spec with the BIG THREE: Context, Model and Prompt(s) to detail the feature you want to build
3. (EXECUTE) Execute your spec in a single shot and watch as your AI Coding Assistant scales your impact across your entire codebase

### Built on Principled AI Coding
Every feature in PAIC Patterns is built on the core principles you've learned in this course:

* **KISS** - Keep your work simple and focused on clear outcomes through clear plans

* **BIG THREE BULLSEYE** - Align your Context, Model and Prompt(s) for concise, precise and repeatable results

* **Use IDKs** - Using specific, powerful keywords in your prompts to generate precise results again and again and again

* **Great Planning is Great Prompting** - Separation of planning and execution through detailed specs

* **Leverage ADWs** - Create reusable AI Developer Workflows and reusable planning assets to solve the same class of problems once and for all

* **Closed Loop Systems** - Use concrete execution commands and feedback loops to 'let the code write itself'

* **Scale your Compute - Scale your Impact** - Hit the sweet spot between lists of low, medium, and high level prompts and run 2, 5, 10, 20+ (not an exaggeration) prompts in one shot

These principles aren't just theory - they're baked into the tool's architecture, so you can effortlessly apply what you've learned in PAIC at scale with MINIMUM effort.


## Principled AI Coding Members only tool for Scaled AI Coding
> This is a members only tool. Visit [Principled AI Coding](https://agenticengineer.com/principled-ai-coding) to learn more.
Curp 2.0
Inter-residue Current calculation in Proteins from MD             trajectory
Requires Python: <3.7,>3.5

======================================
CURP: CURrent calculations in Proteins
======================================

.. image:: https://pepy.tech/badge/curp
    :target: https://pepy.tech/project/curp

**CURP** permits to compute inter-residue flow of energy or heat and atomic stress tensors in a protein, given atomic coordinates and velocity trajectories obtained through molecular dynamics (MD). Energy flow data permit to picture an inter-residue Energy Exchange Network as a graph.
Energy flow data permit to picture an inter-residue Energy Exchange Network as a graph.

Within thermally fluctuating protein molecules under physiological conditions, tightly packed amino acid residues interact with each other through heat and energy exchanges. 
Non-uniform pattern of heat flow in proteins are illustrated and characterized with a theoretical model based on “local heat conductivity” between each residue pair. 
This model demonstrated characteristic features of “hidden dynamic allostery” in PDZ domain [1]_ and allosteric transition in the oxygen sensor domain of FixL [2]_.
Also we applied it to a small protein to understand the features of local thermal transport of protein [3]_ [4]_ [5]_.

Offical website and tutorial can be found at `<https://curp.jp/>`_.

Installation
============
CURP requires Python3.6 with numpy to work.
You can install python here_, or anaconda there_.

.. _here: https://www.python.org/downloads/release/python-3613/
.. _there: https://www.anaconda.com/download

Install CURP via pip
--------------------

::

     pip install curp

Get CURP from source code 
-------------------------

You can get the source code from this repository and build by running following command.

::

    git clone https://github.com/yamatolab/current-calculations-for-proteins.git
    cd current-calculations-for-proteins
    pip install .

Development
===========
Please read DEVELOP.rst before starting to develop CURP.

References
==========

.. [1] Ishikura, T.; Iwata, Y.; Hatano, T.; Yamato, T. Energy exchange network of inter-residue interactions within a thermally fluctuating protein molecule: A computational study. *J. Comput. Chem.* **2015**, 36:1709-1718

.. [2] Ota, T.; Yamato, T. Energy Exchange Network Model Demonstrates Protein Allosteric Transition: An Application to an Oxygen Sensor Protein. *J. Phys. Chem. B* **2019**, 123:768-775

.. [3] Yamato, T.; Wang, T.; Sugiura, W.; Laprévote, O.; Katagiri, T. Computational study on the thermal conductivity of a protein. *J. Phys. Chem. B* **2022**, 126:3029-3036

.. [4] Wang, T.; Yamato, T.; Sugiura, W; Site-selective heat current analysis of α-helical protein with linear-homopolymer-like model. *J. Phys. Chem. B* **2023**, 158

.. [5] Wang, T.; Yamato, T.; & Sugiura, W. Thermal Energy Transport through Nonbonded Native Contacts in Protein. *J. Phys. Chem. B* **2024**
solai 0.1.0
A CLI assistant powered by OpenAI
Requires Python: >=3.6
Keywords: cli, assistant, openai, gpt, command-line

# Solai - Your Smart CLI Assistant

Solai is an AI-powered command-line interface assistant that helps you find and execute the right commands for your tasks. It uses OpenAI's GPT to convert natural language queries into system commands, with built-in safety confirmations and OS-specific command generation.

It came in a dream. "Thank you for this gift."

## Features

- 🤖 Natural language to CLI command conversion
- 💡 Command explanations for better understanding
- ✅ Command confirmation before execution
- 🔒 Secure API key storage
- 💻 OS-specific command generation (macOS, Linux, Windows)
- 🎨 Rich terminal output formatting

## Installation

### Option 1: Install from PyPI (Recommended)
```bash
pip install solai
```

### Option 2: Install from Source
1. Clone the repository:
```bash
git clone https://github.com/caraveo/solai.git
cd solai
pip install -e .
```

## Quick Start

1. First-time setup will prompt for your OpenAI API key
   - Get your API key from: https://platform.openai.com/api-keys
   - The key will be securely stored in `~/.solai.env`

2. Run a command:

```bash
sol find large files
```

Example output:
```bash
Suggested command:
find ~ -type f -size +100M
→ Searches your home directory for files larger than 100 megabytes

Do you want to execute this command? [y/n]:
```

## Usage Examples

```bash
# Find files
sol find all pdf files in downloads

# System maintenance
sol clean up system cache

# Network commands
sol check if google.com is up

# File operations
sol create a backup of my documents
```

## Development

To install in development mode:

```bash
git clone https://github.com/caraveo/solai.git
cd solai
pip install -e .
```

## Requirements

- Python 3.6+
- OpenAI API key
- Required packages:
  - click
  - python-dotenv
  - openai
  - rich

## Configuration

The OpenAI API key is stored in `~/.solai.env`. To update it, simply delete this file and run any sol command to trigger the setup process again.

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -am 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

MIT License

## Contact

Jon Caraveo - jon@ziavision.com

Project Link: [https://github.com/caraveo/solai](https://github.com/caraveo/solai)
metadatamanager 0.1.0
`MetadataManager` 是一个简单的 JSON 元数据管理器，旨在方便地读取、写入和操作 JSON 文件。它提供了一系列方法来管理嵌套的 JSON 数据结构，支持添加、删除、读取和更新操作。
Requires Python: >=3.10

# MetadataManager 使用说明

## 简介

`MetadataManager` 是一个简单的 JSON 元数据管理器，旨在方便地读取、写入和操作 JSON 文件。它提供了一系列方法来管理嵌套的 JSON 数据结构，支持添加、删除、读取和更新操作。

## 特性

- 读取和解析 JSON 文件
- 保存和更新 JSON 文件
- 支持嵌套键的访问
- 支持从列表中添加和删除元素
- 可选的唯一性检查以防止重复项

## 安装

确保您已安装 Python 3.x。将 `metadata_manager.py` 文件下载到您的项目目录中。

```bash
# 克隆或下载代码
git clone https://github.com/amumu2022/MetadataManager.git
cd https://github.com/amumu2022/MetadataManager.git
```

## 使用方法

### 初始化

首先，您需要创建一个 `MetadataManager` 实例。您可以指定缓存目录的名称，默认为 `cache_path`。

```python
from metadata_manager import MetadataManager

manager = MetadataManager(cache_dir='your_cache_directory')
```

### 读取数据

使用 `read` 方法读取 JSON 文件中的数据。您可以提供多个键以访问嵌套数据。

```python
data = manager.read('your_file_name', 'key1', 'key2')
```

如果未提供键，则返回整个字典。

### 添加或更新数据

使用 `add` 方法添加或更新指定嵌套键的值。

```python
manager.add('your_file_name', 'key1', 'key2', value='your_value')
```

### 删除数据

使用 `delete` 方法删除指定嵌套键的值。

```python
success = manager.delete('your_file_name', 'key1', 'key2')
```

### 向列表中添加元素

使用 `add_to_list` 方法向指定键的列表中添加元素。可以选择设置 `unique` 参数以防止添加重复项。

```python
manager.add_to_list('your_file_name', 'your_list_key', value='new_value', unique=True)
```