semvec/pypi-packages huggingface dataset:
filecannon 0.1.6
AI-powered file generation CLI tool
Requires Python: >=3.7

# FileCannon

## Introduction

FileCannon is an AI-powered file generation CLI tool that creates new files based on examples and natural language descriptions. It leverages AI models to generate content, making it easy to quickly create files with a structure similar to provided examples.

## Installation

```bash
pip install filecannon
```

Then, you can use the `filecannon` command with the following syntax:

```bash
filecannon <prompt> [options]
```

### Arguments:

- `prompt`: Description of the file to generate (required)

### Options:

- `-e, --example`: Path to example file(s) (can be used multiple times)
- `-m, --model`: Model to use (default: claude-3-5-sonnet-20240620)
- `-o, --output`: Output directory (default: current directory)

### Example:

```bash
filecannon "Create a Python script that calculates fibonacci numbers" -e examples/math_functions.py -o output/
```

## Files

The main custom files in this project are:

- `filecannon.py`: The main script containing the CLI logic and core functionality
- `ai_manager.py`: Handles AI interactions and prompt management
- `file_manager.py`: Manages file operations and tool implementations
- `tool_parser.py`: Allows XML use of tools by FileCannon

## Methods

### AIManager

- `generate_content(prompt: str, examples: List[str], example_contents: List[str]) -> str`
- `construct_prompt(user_prompt: str, context: dict) -> str`

### FileManager

- `list_files(directory: str) -> List[str]`
- `read_file(path: str) -> str`
- `write_file(path: str, content: str) -> bool`
- `validate_path(path: str) -> bool`

### ToolParser

This component allows XML use of tools by FileCannon. The specific methods are not detailed in the specification.

## Models

FileCannon supports the following AI models:

- Claude 3.5 Sonnet (default)
- OpenAI models (configurable)

## Available CSS styles

This project is a CLI tool and does not include any CSS styles.

## Available JS functions

This project is a CLI tool and does not include any JavaScript functions.

## Additional notes

1. Environment Variables:
   - Set `ANTHROPIC_API_KEY` if using Claude models
   - Set `OPENAI_API_KEY` if using OpenAI models
   - Set `OPENAI_BASE_URL` if using OpenAI (defaults to "https://api.openai.com")

2. Dependencies:
   - openai
   - anthropic

3. This project uses [ai-agent-toolbox](https://github.com/255BITS/ai-agent-toolbox) for tool management and XML handling.

*Part of the [255labs.xyz](https://255labs.xyz) toolkit for AI-first development.*

## License

MIT
metacycle-core 0.1.14
python backend server for metacycle, interacting with bluetooth accessories and controlling carla simulator.
Requires Python: ~=3.10

# Development

```
uv sync
```

We use ruff linter.
```
uvx ruff check
```

# Run

```
uv run metacycle-hello
```

# Upload to PyPI and then run as as a tool

Update version number in `pyproject.toml`

This is how end users will run the server in a single line.

```
rm -r dist/
uv build
uv publish --token $TOKEN
```

Open another terminal (wait a moment for PyPI to be updated):
```
uvx --from metacycle-core@latest metacycle-hello
```
naflow 0.0.4a0
Neurophysiological Data Workflow

# naflow
Neurophysiological Data Workflow

# test
```
python -m unittest discover -s tests
python -m unittest discover -s tests -p "test_*.py"
```

# sphinx
```
sphinx-apidoc -M -E -f -o ./docs ./naflow
sphinx-build ./docs ./docs/_build -a

sphinx-apidoc -M -E -f -o ./docs ./naflow && sphinx-build ./docs ./docs/_build -a
```
py-deepseek-api 1.0.3
Unoffical DeepSeek API for Python
Requires Python: >=3.6

# Unoffical DeepSeek API for Python

A reverse-engineered DeepSeek API. Fully extensible for chatbots and other applications.

---

## Installation
Install the package using pip:

```bash
pip install py-deepseek-api
```

## Usage

### Basic example (streamed):

```python
from deepseek import DeepSeekApi, Conversation

deepseek_api = DeepSeekApi(your_token_here)

conv = Conversation(deepseek_api)

conv.continuous_chat()
```

### How to Get a Token?
You can easily obtain a token using your email and password:
```python
token = deepseek_api.login(email, password)
print(token)
```

### All API methods
For detailed usage and advanced developer guides, refer to the [Wiki](https://github.com/robbinhust/deepseek-api/wiki/).

## Reporting Issues
If you encounter bugs or have feature requests, please open an issue on the [GitHub Issues page](https://github.com/robbinhust/deepseek-api/issues/). Make sure to provide detailed information and steps to reproduce the problem.

## Disclaimer
This API is intended for educational purposes only. Any use for commercial purposes is strictly prohibited without prior permission. If any violation occurs, please contact me for immediate removal.
FastAAI-release 0.0.1
A rapid estimator for amino acid identity between genomes.
Requires Python: >=3

# FastAAI

Author: Kenji Gerhardt
Email:  Kenji.Gerhardt@gmail.com
Author: Carlos Ruiz Perez
Email:  carlos.vernichtung@gmail.com

FastAAI uses tetramer frequency over shared universal sincle copy proteins to rapidly and accurately estimate average whole-genome amino acid identity.
asyncio-lifx-scenes 0.1.0
List and activate scenes via the LIFX Cloud.
Requires Python: <4.0,>=3.12
Keywords: python

# asyncio-lifx-scenes

[![Release](https://img.shields.io/github/v/release/djelibeybi/asyncio-lifx-scenes)](https://img.shields.io/github/v/release/djelibeybi/asyncio-lifx-scenes)
[![Build status](https://img.shields.io/github/actions/workflow/status/djelibeybi/asyncio-lifx-scenes/main.yml?branch=main)](https://github.com/djelibeybi/asyncio-lifx-scenes/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/djelibeybi/asyncio-lifx-scenes/branch/main/graph/badge.svg)](https://codecov.io/gh/djelibeybi/asyncio-lifx-scenes)
[![Commit activity](https://img.shields.io/github/commit-activity/m/djelibeybi/asyncio-lifx-scenes)](https://img.shields.io/github/commit-activity/m/djelibeybi/asyncio-lifx-scenes)
[![License](https://img.shields.io/github/license/djelibeybi/asyncio-lifx-scenes)](https://img.shields.io/github/license/djelibeybi/asyncio-lifx-scenes)

List and activate scenes via the LIFX Cloud either synchronously or asynchronously.

- **Github repository**: <https://github.com/djelibeybi/asyncio-lifx-scenes/>
- **Documentation** <https://djelibeybi.github.io/asyncio-lifx-scenes/>


---

Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
answer-college-supplemental 0.6
A CLI tool for gaining inspiration for college supplementals. Do NOT submit these generated essays to colleges.

# answer_college_supplemental

# For my Caltech Supplemental Nine Essay

[![PyPI - Version](https://img.shields.io/pypi/v/answer-college-supplemental.svg)](https://pypi.org/project/answer-college-supplemental)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/answer-college-supplemental.svg)](https://pypi.org/project/answer-college-supplemental)

---

## Table of Contents

- [Internals](#internals")
- [Installation](#installation)
- [License](#license)

## Internals

- First, I created a Flask app as the backend and hosted it on Vercel. Since I use Google Gemini to create the essay response, I need to keep the Google Gemini API Key safe and secure, which isn't possible if I were to include it in the Python package.
- Second, I created the CLI tool using the built-in Argparse module to create the flag arguments. Then, I used requests to send a response to my Flask app, which calls Google Gemini. I send the Google Gemini response back to the CLI tool, which saves it to the output file.

## Installation

```console
pip install answer-college-supplemental
```

## License

`answer-college-supplemental` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
desmospy 0.0.5
pythonic desmos
Requires Python: >=3.8

> [!NOTE]
> 
> [See a live view as a Jupyter notebook.](https://nbviewer.org/github/timdechant/desmospy/blob/main/README.ipynb)
> 
> [See source code and more examples on github.](https://github.com/timdechant/desmospy)

<code>desmospy</code> has these immediate goals:
  - present the Desmos API with consistent terminology
  - keep it simple, keep it pythonic

Basic usage is very simple.  Create an instance of <code>Calculator</code>, then assign to one of its members.


```python
from desmospy import Calculator

c = Calculator()
c.y = 1/2 * c.x + 3
c.show()
```

[![Figure 1](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig1.png)](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig1.png)

More advanced plots can be created with comparisons and the <code>.set()</code> method:


```python
c.a = 0.3
a,x,y = c.a,c.x,c.y

c.set(y < a*x)
c.set(y >= a*x**2)
c.set(a*x*y == 1)
c.show()
```

[![Figure 2](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig2.png)](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig2.png)

Equations and inequalities can also be combined; first let's define two ellipse regions.


```python
A = (x**2 / 49 + y**2 / 16 <= 1)
B = (x**2 / 16 + y**2 / 49 <= 1)
```

We can then take the union, also known as a logical OR <code>|</code> of the regions.


```python
c.set(A | B)
c.show()
```

[![Figure 3](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig3.png)](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig3.png)

We can also take the intersection of the same regions, with the logical AND <code>&</code> operation.


```python
c.set(A & B)
c.show()
```

[![Figure 4](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig4.png)](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig4.png)

This leaves the logical XOR <code>^</code> operation.


```python
c.set(A ^ B)
c.show()
```

[![Figure 5](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig5.png)](https://raw.githubusercontent.com/timdechant/desmospy/main/img/README_fig5.png)
intermag 0.0.2
Python library to auto-download, manipulate, and process magnetic data from INTERMAGNET sites
Keywords: War Thunder

# intermag

Python library to auto-download, manipulate, and process magnetic data from INTERMAGNET sites

## Example Python Script

``` python
import datetime as dt
import intermag as im


ds = im.IM_Dataset()
ds.download_dataset(iaga_code    = 'BOU',
                    start_date   = dt.datetime(2025, 1, 1),
                    load_dataset = True,
                    num_days     = 2,
                    save_dir     = os.path.dirname(__file__))

print(ds.attrs())
print(ds.data())

ds.plot_data()
```

## Command Line Usage

``` cmd
options:
  -h, --help    show this help message and exit
  -l, --loc     IAGA location code (3-letter)
  -y, --year    Start year of dataset
  -m, --month   Start month of dataset
  -d, --day DAY Start day of dataset
  -u, --dur DUR Duration of dataset in whole number of days
  -p, --plot    Bool of whether or not to plot the dataset
  -s, --savedir Directory to save the dataset to
```

``` cmd
python intermagnet -l BOU -y 2025 -m 1 -d 1 -u 1 -p True -s <dataset file path>
```