semvec/pypi-packages huggingface dataset:
oroatlo 0.1.0
A CLI tool for TLO searches
Requires Python: >=3.8

# OroaTLO CLI

A command-line interface for TLO searches.

## Installation

```bash
pip install oroatlo
```

## Configuration

First, configure your admin key:

```bash
oroatlo config --admin-key "your-key"
```

## Usage

```bash
# Search by name
oroatlo search --first-name "John" --last-name "Doe"

# Search by address
oroatlo search --street "123 Main St" --city "New York" --state "NY"

# Override saved admin key for a single search
oroatlo search --first-name "John" --last-name "Doe" --admin-key "different-key"
```

## Features

- Person search by name or address
- Persistent admin key configuration
- Rich terminal output
- Easy to use command-line interface

## License

MIT
oraotlo 0.1.0
A CLI tool for TLO searches
Requires Python: >=3.8

# OraoTLO CLI

A command-line interface for TLO searches.

## Installation

```bash
pip install oraotlo
```

## Configuration

First, configure your admin key:

```bash
oraotlo config --admin-key "your-key"
```

## Usage

```bash
# Search by name
oraotlo search --first-name "John" --last-name "Doe"

# Search by address
oraotlo search --street "123 Main St" --city "New York" --state "NY"

# Override saved admin key for a single search
oraotlo search --first-name "John" --last-name "Doe" --admin-key "different-key"
```

## Features

- Person search by name or address
- Persistent admin key configuration
- Rich terminal output
- Easy to use command-line interface

## License

MIT
workday-mcpserver-py 0.1.0
WORKDAY is an HRMS
Requires Python: >=3.12

# MCP Development Tools Setup Guide

## Prerequisites

- Python 3.x
- UV package installer
- Claude Desktop (for integration)

## Installation

1. Install UV (if not already installed):
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Install dependencies using UV:
```bash
uv add requirement.txt
uv add "mcp[cli]"
```

## Usage

### Running MCP Command
To execute the MCP command using UV:
```bash
uv run mcp
```

### Running MCP Inspector
To start the MCP inspector:
```bash
mcp dev server.py
```

## Claude Desktop Integration

### Basic Installation
Install your server in Claude Desktop:
```bash
mcp install server.py
```

### Advanced Installation Options

#### Custom Server Name
To install with a custom name:
```bash
mcp install server.py --name "My Analytics Server"
```

#### Environment Variables
There are two ways to configure environment variables:

1. Direct specification:
```bash
mcp install server.py -v API_KEY=abc123 -v DB_URL=postgres://...
```

2. Using an environment file:
```bash
mcp install server.py -f .env
```

## Additional Resources

For more detailed information about MCP tools and their usage, please refer to the official documentation.
boto3-mfa-cache 1.0.0
A patch for boto3 to use the AWS CLI credential cache. This uses 

## Boto3 MFA Cache

This package patches boto3 to use the AWS CLI credential cache. This uses the same cache as the AWS CLI, 
which is stored in `~/.aws/cli/cache`. This allows you to use MFA with boto3 without having to 
enter your credentials every time. The environment variable AWS_CREDENTIAL_CACHE can be set to a 
different path if `~/.aws/cli/cache` is not what you want to use.

This pull is the primary reference for this package: https://github.com/boto/botocore/pull/1338

## Best Practices

This is designed for use with role-assumption based MFA. That's you if your `~/.aws/config` looks something like this:

```ini
[default]
role_arn = arn:aws:iam::123456789012:role/MyRole
source_profile = base
region = us-east-2
mfa_serial = arn:aws:iam::123456789012:mfa/my-device
duration_seconds = 43200
```

This project is only useful on development environments that require MFA. Servers and other automated resources
should not require MFA, and thus should not require this package.

```bash
python -m pip install boto3-mfa-cache
```

## Methodology

The patch works by loading a .pth file that imports a monkeypatch replacing `boto3.setup_default_session`
with a patched version. The patched version applies the JSONFileCache from botocore (also used by the CLI)
to the default credential provider.

```python
import os
import boto3
import botocore.session
from botocore.utils import JSONFileCache

def _setup_default_session_patch(**kwargs):
    cli_cache_path = os.environ.get(
        "AWS_CREDENTIAL_CACHE",
        os.path.join(os.path.expanduser("~"), ".aws", "cli", "cache")
    )
    os.makedirs(cli_cache_path, exist_ok=True)
    botocore_session = botocore.session.Session()
    file_cache = JSONFileCache(cli_cache_path)
    botocore_session.get_component("credential_provider").get_provider("assume-role").cache = file_cache
    boto3.DEFAULT_SESSION = boto3.Session(botocore_session=botocore_session, **kwargs)

boto3.setup_default_session = _setup_default_session_patch
```
sanctiontlo 0.1.0
A CLI tool for TLO searches
Requires Python: >=3.8

# SanctionTLO CLI

A command-line interface for TLO searches.

## Installation

```bash
pip install sanctiontlo
```

## Configuration

First, configure your admin key:

```bash
sanctiontlo config --admin-key "your-key"
```

## Usage

```bash
# Search by name
sanctiontlo search --first-name "John" --last-name "Doe"

# Search by address
sanctiontlo search --street "123 Main St" --city "New York" --state "NY"

# Override saved admin key for a single search
sanctiontlo search --first-name "John" --last-name "Doe" --admin-key "different-key"
```

## Features

- Person search by name or address
- Persistent admin key configuration
- Rich terminal output
- Easy to use command-line interface

## License

MIT
python-expokar 0.1.4
A collection of machine learning algorithm implementations with ready-to-use experiments
Requires Python: >=3.6
Keywords: machine learning, neural networks, logistic regression, SVM, experiments

# Python Expokar

A comprehensive collection of machine learning algorithm implementations including Logistic Regression, Support Vector Machines (SVM), Neural Networks, Principal Component Analysis (PCA), and more.

## Installation

```bash
pip install python-expokar
```

## Features

- **Linear Regression**: Base, Ridge (L2) and Lasso (L1) implementations
- **Logistic Regression**: Implementation with various regularization options
- **Support Vector Machines**: Implementation with multiple kernel options
- **Neural Networks**: McCulloch-Pitts neuron and Hebbian learning implementations
- **Principal Component Analysis (PCA)**: Dimensionality reduction implementation

## Usage Examples

### Linear Regression
```python
from python_expokar.ml.linear_regression import Ridge, Lasso

# Ridge Regression
ridge_model = Ridge(alpha=1.0)  # L2 regularization strength
ridge_model.fit(X_train, y_train)
ridge_predictions = ridge_model.predict(X_test)

# Lasso Regression
lasso_model = Lasso(alpha=1.0)  # L1 regularization strength
lasso_model.fit(X_train, y_train)
lasso_predictions = lasso_model.predict(X_test)
```

### Logistic Regression
```python
from python_expokar.ml import CustomLogisticRegression

# Create and train the model
model = CustomLogisticRegression(learning_rate=0.01, n_iterations=1000)
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)
```

### Support Vector Machine
```python
from python_expokar.ml import SVM

# Train SVM with different kernels
svm_model = SVM(kernel='rbf', gamma='scale', C=1.0)
svm_model.fit(X_train, y_train)
```

### Neural Networks
```python
from python_expokar.ml import HebbianNeuron

# Create and train a Hebbian neuron
neuron = HebbianNeuron(input_size=2, learning_rate=0.1)
neuron.train_hebbian(X_train, y_train)
```

## Requirements

- Python >= 3.6
- NumPy >= 1.19.0
- scikit-learn >= 0.24.0
- matplotlib >= 3.3.0
- pandas >= 1.2.0
- seaborn >= 0.11.0

## License

This project is licensed under the MIT License - see the LICENSE file for details.
tldr-tools 0.2.4.4
Use TLDR for dockopt, decoy generation, and job management.
Requires Python: >=3.10

## What is it?

A toolkit to interface [https://tldr.docking.org/](https://tldr.docking.org/), a webserver home to a collection of docking optimization and benchmark molecular docking programs.

## Installation

Installation is super easy and pip installable. Please make sure you have Python 3.6 installed.

```shell-session
$ pip install tldr-tools
```

The API_KEY, as found on the top right corner under tldr.docking.org, must be set as an environmental variable before usage. The API_KEY can be assigned in .env under the package root, or directly set in terminal.

```shell-session
# Method 1: Add under .env (recommended for for python notebooks)
$ echo "API_KEY=SOMESECRETKEY" > .env

# Method 2: Manually setting API_KEY (recommended for interactive jobs)
export API_KEY="SOMESECRETKEY"
```

## Usage
To view the current implemented modules in tldr-tools, please run:

```shell-session
$ tldr-submit --list-modules
```

For example, if running decoy generation is desired:

```shell-session
tldr-submit --module decoys --activesism input_files/actives.ism --decoygenin input_files/decoy_generation.in --memo "Decoy generation for ADA, replicate 1"
```

Or, you can build a ligand using DOCK38:

```shell-session
tldr-submit --module build --input chaff_tools/aggregator_advisor_hf_test.txt --memo "aa_hf_test"
```

Documenting runs with the optional memo parameter is encouraged.

Pass in a job number to check on a status of a run:
```shell-session
tldr-status --job-number 14886
```

Once a run is successful, you can download the output to a local directory:

```shell-session
tldr-download --job-number 14886 --output some_folder
```

## Does tldr-tools work in Colab and Jupyter Notebook?

Yep, you use tldr-tools as follow:

```shell-session
from tldr_tools.tldr_submit import *        # Import to submit new jobs
from tldr_tools.tldr_endpoint import *      # Import for APIManager() which is responsible for handling requests (api_token and headers)
from tldr_tools.tldr_status import *        # Import to check on status

api_manager = APIManager()
module_name = "build"

kwargs = {
   "input": "aggregator_advisor_hf_test.txt",
   "memo": "aa_hf_test"
}

# Submit the module
job_number = submit_module(api_manager, module_name, **kwargs)
```

## Extending tldr-tools

Community and expansion is encouraged and made easy with this codebase. Adding new modules that are newly introduced on https://tldr.docking.org/ is painless, and is as simple as adding a new Endpoint and required/optional list of files.
llm-logging-debug 0.1
Set logging.DEBUG while running LLM
Requires Python: >=3.9

# llm-logging-debug

[![PyPI](https://img.shields.io/pypi/v/llm-logging-debug.svg)](https://pypi.org/project/llm-logging-debug/)
[![Changelog](https://img.shields.io/github/v/release/simonw/llm-logging-debug?include_prereleases&label=changelog)](https://github.com/simonw/llm-logging-debug/releases)
[![Tests](https://github.com/simonw/llm-logging-debug/actions/workflows/test.yml/badge.svg)](https://github.com/simonw/llm-logging-debug/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/llm-logging-debug/blob/main/LICENSE)

Set logging.DEBUG while running LLM

## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-logging-debug
```
## Usage

Set the `LLM_LOGGING_DEBUG` environment variable to `1` before running LLM:
```bash
export LLM_LOGGING_DEBUG=1
llm "Say hello in five languages" -m gemma3:27b
```
Or just for one invocation like this:
```bash
LLM_LOGGING_DEBUG=1 llm "Say hello in five languages" -m gemma3:27b
```
This will set the Python logging level to `DEBUG` for the duration of the LLM command.

One consequence of this is that plugins that use `httpx` will show detailed debugging information about the requests they are making.

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-logging-debug
python -m venv venv
source venv/bin/activate
```
Now install the dependencies and test dependencies:
```bash
python -m pip install -e '.[test]'
```
To run the tests:
```bash
python -m pytest
```
mcp-youtube-search 0.1.4
A YouTube search MCP server for AI agents
Requires Python: >=3.8

# MCP YouTube Server

A YouTube search server for AI agents using Google's Agent Development Kit (ADK) and Model Control Protocol (MCP).

## Installation

```bash
pip install mcp-youtube-search
```

## Usage

### Running the server

```bash
# Set your SerpAPI key as an environment variable
export SERP_API_KEY="your-serp-api-key"

# Start the server
mcp-youtube-search
```

Or provide the API key directly:

```bash
mcp-youtube-search --api-key "your-serp-api-key"
```

### Using with MCP clients

```python
import asyncio
import os
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

async def main():
    # Connect to the MCP server
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command="mcp-youtube-search",
            env={"SERP_API_KEY": os.getenv("SERP_API_KEY")}
        )
    )
    
    try:
        # Use the first tool (should be search_youtube)
        youtube_tool = tools[0]
        results = await youtube_tool.run_async(
            args={"search_query": "Python tutorials", "max_results": 5},
            tool_context=None
        )
        print(results)
    finally:
        await exit_stack.aclose()

asyncio.run(main())
```

## Requirements

- Python 3.11+
- SerpAPI key (get one at https://serpapi.com/)