semvec/pypi-packages huggingface dataset:
ai-terminal-cli 0.1.6
Terminal assistant built as an open source minimal alternative to Warp
Requires Python: >=3.12
Keywords: terminal, ai, shell, assistant, cli, gemini

# AI-Terminal

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
[![Platform](https://img.shields.io/badge/platform-linux-lightgrey.svg)](https://github.com/your-username/ai-enabled-terminal)

Terminal assistant which is built as an open source minimal alternative to warp.

## Quick Start

### Prerequisites

- Python 3.12 or higher
- Linux operating system (Ubuntu, Arch, Fedora, CentOS, openSUSE, Debian supported) (Windows and MacOS will be supproted later on)
- Google Gemini API key ([Get one here](https://aistudio.google.com/app/apikey))

### Installation

#### Option 1: Binary Release (Recommended)

1. Download the latest release from [Releases](https://github.com/your-username/ai-enabled-terminal/releases)
2. Extract and install:

   ```bash
   tar -xzf ai-terminal-linux.tar.gz
   cd ai-terminal-linux
   sudo ./install.sh
   ```

3. Launch the terminal:

   ```bash
   ai-terminal
   ```

4. Enter your Gemini API key when prompted

#### Option 2: From Source

1. Clone the repository:

   ```bash
   git clone https://github.com/Abhinavexists/ai-terminal.git
   cd ai-enabled-terminal
   ```

2. Create and activate virtual environment:

   ```bash
   python -m venv .venv
   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
   ```

3. Install dependencies:

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

4. Set up your API key:

   ```bash
   export GEMINI_API_KEY="your-api-key-here"
   ```

5. Run the application:

   ```bash
   python -m terminal.cli
   ```

## Usage Examples

```bash
# Natural language commands
> install docker
Command: sudo pacman -S docker
Explanation: Installs Docker using the system package manager

> find all python files in current directory
Command: find . -name "*.py" -type f
Explanation: Searches for all Python files in the current directory and subdirectories

> compress folder into zip
Command: zip -r archive.zip folder_name
Explanation: Creates a ZIP archive of the specified folder

> show disk usage sorted by size
Command: du -sh * | sort -hr
Explanation: Shows disk usage of all items in current directory, sorted by size
```

## Contributing

We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

## Pending stuff

- [ ] Support for Windows and macOS
- [ ] Custom command templates and aliases
- [ ] Plugin system for extending functionality
- [ ] Command explanation and learning mode
- [ ] Integration with popular development tools
- [ ] Multi-language support

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
siphash24 1.8
Streaming-capable SipHash-1-3 and SipHash-2-4 Implementation
Requires Python: >=3.7

.. SPDX-FileCopyrightText: Daniele Nicolodi <daniele@grinta.net>
.. SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

siphash24: Streaming-capable SipHash Implementation
===================================================

This module provides a C-based implementation of `SipHash`__ with an
interface compatible with the hash functions provided by the
`hashlib`__ standard library module.  SipHash-1-3 and SipHash-2-4
variants are currently implemented.  The module `documentation`__
provides a detailed description of the API.

This module differs from other similar modules by providing a
streaming-capable implementation and an interface compatible to the
hash functions provided by the ``hashlib`` standard library module and
by providing binary wheels for all supported Python releases on the
most common platforms.  More platforms can be added to the build job
as needed.

Following the ``hashlib`` interface, the return value of the
``digest()`` method is a ``bytes`` object.  SipHash values are
customarily stored as 64-bit integers.  This module extends the
``hashlib`` interface with an additional ``intdigest()`` method that
returns the hash values as a 64-bit signed int object.

This module is implemented as a thin `Cython`__-based wrapper around a
C language SipHash implementation copied, with minimal modifications
to allow compilation with MSCV, from the `c-siphash library`__ by
David Rheinsberg and co-authors.  The c-siphash library is based on
the SipHash `reference implementation`__ by Jean-Philippe Aumasson and
Daniel J. Bernstein released to the Public Domain.  This module is
distributed with the same license as the c-siphash library:
`Apache-2.0`__ or `LGPL-2.1-or-later`__.

__ https://cr.yp.to/siphash/siphash-20120918.pdf
__ https://docs.python.org/3/library/hashlib.html
__ https://dnicolodi.github.io/python-siphash24/
__ https://cython.org/
__ https://github.com/c-util/c-siphash
__ https://github.com/veorq/SipHash
__ https://spdx.org/licenses/Apache-2.0.html
__ https://spdx.org/licenses/LGPL-2.1-or-later.html
xum 0.3.4
Manage Tmux session for selected folders and SSH hosts
Requires Python: >=3.11

# `xum` - tmux session manager
Yes, it's another sessionizer using `tmux` and `fzf`.
Inspired by [ThePrimeagen's sessionizer](https://github.com/ThePrimeagen/tmux-sessionizer),
as most tmux sessionizers.

## Dependencies
- `tmux`
- `python` (at least 3.13)
- `zoxide`
- `fzf`
- `make` (devel only)

## Installation
Download the binary from the *Releases* and place it into a directory that's on PATH.

Otherwise, using `pipx`
```bash
pipx install xum
```

## Usage
`xum` is a simple Tmux session manager, it can be used to **create**, **attach to** and **delete** sessions.

There are four subcommands:
- `create`: list available directories among the ones provided (see below) and open a new window of a new session.
- `here`: create a new session in the current directory, for directory you visit less often.
- `switch`: list the currently open sessions and attach to the selected one.
- `close`: close selected session.

When creating new sessions `xum` uses *three* providers to generate a list of directories:
- `fd`: list all directories in a collection of watchdirs (see [Configuration] below).
- `zoxide`: list the directories in zoxide database.
- `custom_paths`: return manually specified entries (see [Configuration] below).

## Configuration
Configuration is performed by modifing the config file at `~/.config/xum/xum.toml`.

Here is an example configuration:
```toml
# search paths for fd
search_paths = ["~/projects"]
# additional manual entries
custom_paths = ["~/dotfiles"]
```

- `search_paths`
Define the directories on which to run `fd`. This will look for all directories contained therein.

- `custom_paths`
You can add individual directories to the list of available paths.

## Build from source
You can build your own version of `xum` using `nuitka`, which is a development requirement of the project.
Ensure `make` is installed on your system.
To build the binary use
```bash
make build
```
The binary can be found at `build/xum`.
To install it just copy it to a directory which is on PATH, or run
```bash
make install
```
to install it to `~/.local/bin`.
proteinpy 0.1.2
A Python toolkit for fetching and analyzing protein sequences.
Requires Python: >=3.7

# ProteinPy

A Python toolkit for fetching and analyzing protein sequences.

## Features

- **Sequence Retrieval**  
  Retrieve protein sequences directly from the UniProt Knowledgebase via accession IDs.

- **Biochemical Property Analysis**  
  Calculate key biochemical properties such as:  
  - Molecular weight  
  - Isoelectric point (pI)  
  - GRAVY (Grand Average of Hydropathicity)  
  - Aromaticity  
  - Aliphatic index  

- **Sequence Manipulation**  
  - Extract sub-sequences and generate sliding k-mers  
  - Perform amino acid mutations (single or batch)  
  - Identify sequence motifs using custom regular expressions  

- **Data Export**  
  Export sequences in FASTA format and analytical results in JSON or CSV.

- **Visualization**  
  Create amino acid composition and distribution plots using Matplotlib.

- **Reporting**  
  Generate clear, user-friendly summary reports for quick interpretation.

---




## Installation

```bash
pip install proteinpy

```


## Example Usage

```bash
from proteinpy import Protein

# Initialize a protein object with a UniProt accession
p = Protein("P69905")  # Hemoglobin alpha subunit

# Fetch and print summary statistics
p.summary()

# Get amino acid counts and visualize them
p.aa_counts()
p.aa_distribution()

# Simulate a mutation at position 42
mutated_seq = p.mutate(42, "K")

# Find a motif using regex
positions = p.find_motif("N[^P][ST][^P]")

# Export as JSON or CSV
p.to_json()
p.to_csv("P69905.csv")


```