semvec/pypi-packages huggingface dataset:
sortepack 0.0.1
Pacote para sortear números e itens aleatórios.
Requires Python: >=3.8

# sortepack

Description. 
The package sortepack is used to:
	Sorteios:
		- Sortear nÃºmero inteiro aleatÃ³rio
		- Sortear item aleatÃ³rio de uma lista 

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_name
```


## Author
Andi

## License
[MIT](https://choosealicense.com/licenses/mit/)
namecheap-cli 0.2.0
A command-line interface for managing Namecheap DNS records
Requires Python: >=3.6

# Namecheap CLI

A command-line interface for managing Namecheap DNS records.

## Features

- List all domains in your Namecheap account
- View DNS records for a domain
- Add, update, and delete DNS records
- Interactive menu for easier management
- Secure storage of API credentials

## Installation

```bash
pip install namecheap-cli
```

Or install directly from GitHub:

```bash
pip install git+https://github.com/connorodea/namecheap-cli.git
```

## Usage

### Interactive Mode

For the easiest usage, simply run the command without any arguments to enter interactive mode:

```bash
namecheap
```

This will display a menu similar to:

```
╭─────────────╮
│ Namecheap CLI │
╰─────────────╯

Please select an option:

[1] List domains
[2] View DNS records
[3] Add DNS record
[4] Update DNS record
[5] Delete DNS records
[0] Exit

Enter your choice [0/1/2/3/4/5] (0):
```

### Command-Line Arguments

You can also use command-line arguments for scripting or automation:

```bash
# Initialize API credentials
namecheap init

# List all domains
namecheap domains

# List DNS records for a domain
namecheap records example.com

# Add a DNS record
namecheap add -d example.com -t A -h www -v 192.168.1.1 -l 3600

# Update a DNS record
namecheap update -d example.com -t A -h www -v 192.168.1.2 -l 3600

# Delete a DNS record
namecheap delete -d example.com -t A -h www
```

### Getting Help

For more information on the available commands and options:

```bash
namecheap --help
```

## API Credentials

Upon first use, the CLI will prompt you for your Namecheap API credentials:

- API Key
- API User
- Username (usually the same as API User)
- Client IP (detected automatically)

These credentials are securely stored in `~/.namecheap/config.json` for future use.

To obtain API credentials from Namecheap:

1. Log in to your Namecheap account
2. Go to Profile > Tools > API Access
3. Enable API access and note your API key
4. Your client IP must be whitelisted in the Namecheap API settings

## License

MIT License

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Environment Variables

Instead of storing credentials in the config file, you can use environment variables:

- `NAMECHEAP_API_KEY` - Your Namecheap API key
- `NAMECHEAP_API_USER` - Your Namecheap API user
- `NAMECHEAP_USERNAME` - Your Namecheap username (optional, defaults to API_USER)
- `NAMECHEAP_CLIENT_IP` - Your client IP address (optional, auto-detected if not provided)
- `NAMECHEAP_USE_SANDBOX` - Whether to use the sandbox environment (optional, defaults to false)

You can set these variables in your shell:

```bash
export NAMECHEAP_API_KEY="your_api_key"
export NAMECHEAP_API_USER="your_api_user"
acace_text_preprocessor 0.1.1
Text preprocessing utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE Text Preprocessor

A text preprocessing module for the Adaptive Context-Aware Content Engine (ACACE).

## Features

- HTML tag removal and entity decoding
- Whitespace normalization
- Simple and efficient text cleaning

## Installation

```bash
pip install acace_text_preprocessor
```

## Usage

```python
from acace_text_preprocessor import preprocess_text

# Clean and normalize text
cleaned_text = preprocess_text("Your <b>HTML</b> text with   extra   spaces")
print(cleaned_text)  # Output: "Your HTML text with extra spaces"
```

## License

MIT License
acace_web_interface 0.1.0
Web interface for ACACE
Requires Python: <4.0,>=3.8

# ACACE_WEB_INTERFACE

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_web_interface
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_vector_store 0.1.0
Vector storage utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_VECTOR_STORE

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_vector_store
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
ai-commit-gen 0.61
A binary to generate commit messages using generative models.

# Ai-Commit-Gen

Ai-Commit-Gen is a Python binary that leverages various language models to generate meaningful commit messages. There's approximately a thousand such binaries out there, but none that fit into all of my workflows, so here's the 1001st.

ai-commit-gen can be called from scripts to automatically create commits, or integrated into editor workflows to create commit drafts.

## Installation

```bash
pip install ai-commit-gen
```

## Usage

ai-commit-gen assumes that the current working directory is, or is a subdirectory of, the git root.

- `-p` or `--prompt`: Override the default prompt for the language model. Available presets are "default", "refactoring", "documentation", and "mimic".

- `-c` or `--commit`: Not only generate a commit message but also commit the changes in git.

- `-m` or `--model`: Specify the model to be used. The default is "gpt-4o-mini". Supports a wide range of models from various providers through litellm.

- `-d` or `--debug`: Enable debug logging.

- `--apibase`: Specify a custom API base URL for the model provider.

## Supported Models

Ai-Commit-Gen uses litellm, which supports a wide range of language models from various providers. Some of the supported models include:

- OpenAI models (e.g., gpt-3.5-turbo, gpt-4)
- Anthropic models (e.g., claude-2)
- Local models via Ollama (e.g., ollama/llama3.1)

For a full list of supported models, please refer to the [litellm documentation](https://docs.litellm.ai/docs/providers).

## API Keys

For cloud-based models (like OpenAI or Anthropic), you'll need to provide an API key. The key can be set as an environment variable or stored in the system keyring:

- For OpenAI: Use `OPENAI_API_KEY` environment variable or store in keyring as "openai_key"
- For Anthropic: Use `ANTHROPIC_API_KEY` environment variable or store in keyring as "anthropic_key"

If the key is not found when the script is run, you will be prompted to enter it and given the option to store it in the keyring.

## Example

Here is an example of how you might use Ai-Commit-Gen:

```bash
# Stage your changes
git add .

# Just create the commit message
ai-commit-gen

# Generate a commit message and commit the changes
ai-commit-gen --commit

# Use a specific model
ai-commit-gen --model gpt-4

# Use a local model via Ollama
ai-commit-gen --model ollama/llama3.1

# Use a custom API base URL
ai-commit-gen --apibase "https://custom-api-endpoint.com/v1"
```
acace_topic_extractor 0.1.0
Topic extraction utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_TOPIC_EXTRACTOR

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_topic_extractor
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_sentiment_analyzer 0.1.0
Sentiment analysis utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_SENTIMENT_ANALYZER

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_sentiment_analyzer
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_semantic_analyzer 0.1.0
Semantic analysis utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_SEMANTIC_ANALYZER

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_semantic_analyzer
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_coherence_checker 0.1.0
Text coherence checking utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_COHERENCE_CHECKER

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_coherence_checker
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_llm_adapter 0.1.0
LLM adapter utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE LLM Adapter

A Language Model adapter module for the Adaptive Context-Aware Content Engine (ACACE).

## Features

- OpenAI API integration
- Anthropic API integration
- Unified interface for multiple LLM providers
- Error handling and retries

## Installation

```bash
pip install acace_llm_adapter
```

## Usage

```python
from acace_llm_adapter import LLMAdapter

# Initialize with your API keys
adapter = LLMAdapter(
    openai_api_key="your-openai-key",
    anthropic_api_key="your-anthropic-key"
)

# Generate content using OpenAI
response = adapter.generate(
    "Write a short story about a robot learning to paint.",
    provider="openai",
    model="gpt-4"
)

# Generate content using Anthropic
response = adapter.generate(
    "Write a short story about a robot learning to paint.",
    provider="anthropic",
    model="claude-3-opus-20240229"
)
```

## License

MIT License
acace_context_storage 0.1.0
Context storage utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE Context Storage

A context storage module for the Adaptive Context-Aware Content Engine (ACACE).

## Features

- Session-based context storage
- Context retrieval and updates
- Memory-efficient storage
- Simple API

## Installation

```bash
pip install acace_context_storage
```

## Usage

```python
from acace_context_storage import ContextStorage

# Initialize context storage
storage = ContextStorage()

# Store context for a session
storage.store_context("session1", "This is the context for session 1")

# Retrieve context
context = storage.get_context("session1")
print(context)  # Output: "This is the context for session 1"

# Update context
storage.store_context("session1", "Updated context for session 1")
```

## License

MIT License
acace_compression_engine 0.1.0
Text compression utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE Compression Engine

A semantic text compression engine for the Adaptive Context-Aware Content Engine (ACACE).

## Features

- Token-based compression
- Semantic preservation
- Weight-based token filtering
- Configurable compression ratios

## Installation

```bash
pip install acace_compression_engine
```

## Usage

```python
from acace_compression_engine import compress_text
from acace_token_weightor import assign_weights
from acace_tokenizer import tokenize_text

# Prepare tokens with weights
tokens = tokenize_text("Your text to compress with important information.")
weighted_tokens = assign_weights(tokens)

# Compress text while preserving semantics
compressed_text = compress_text(weighted_tokens, compression_ratio=0.7)
print(compressed_text)
```

## License

MIT License
acace_retry_handler 0.1.0
Retry handling utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_RETRY_HANDLER

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_retry_handler
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_metrics_collector 0.1.0
Metrics collection utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_METRICS_COLLECTOR

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_metrics_collector
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License
acace_error_handler 0.1.0
Error handling utilities for ACACE
Requires Python: <4.0,>=3.8

# ACACE_ERROR_HANDLER

Component of the Adaptive Context-Aware Content Engine (ACACE).

## Installation

```bash
pip install acace_error_handler
```

## Features

- Core functionality for ACACE
- Integration with other ACACE components

## License

MIT License