semvec/pypi-packages huggingface dataset:
flake8-explicitclassvar 0.1.0
A demo flake8 plugin that tries to protect against Python mutable defaults issue
License: MIT
Requires Python: >=3.9
Keywords: flake8, plugin, typing, ClassVar

# flake8-explicitclassvar

A demo flake8 plugin that tries to protect against [Python mutable defaults issue]().

## Development
1. Create a venv: `uv venv`
2. Activate it: `source .venv/bin/activate`
3. Install the plugin in editable mode: `uv pip install -e .`
4. Run Flake8: `flake8 tests/`

## Rule
- `ECV100`: class variable must be annotated with ClassVar or have a default of None"
just-agents-examples 0.8.9
Just Agents - Examples code
License: MIT
Requires Python: <3.15,>=3.10

Just-Agents Examples
====================

Examples of using Just Agents for various tasks:

* basic - basic examples of using Just Agents
* coding - generating and executing code and commands (note: require docker to be installed)
* tools - tools used by examples
* multiagent - multiagent examples
just-agents-router 0.8.9
Just Agents - Router Components
License: MIT
Requires Python: <3.15,>=3.10

# Just-Agents Router

The router module in just-agents provides functionality for routing conversations and tasks between different agents. This enables complex multi-agent interactions where specialized agents can handle different aspects of a task.

## Key Components

### SecretaryAgent
The SecretaryAgent acts as a routing coordinator, determining which agent should handle specific requests. As shown in the tests, it maintains a configuration that can be loaded from YAML files and includes:

- Agent descriptions and roles
- Personality traits
- Model configurations
- Routing rules

### Example Usage

Here's a simplified test setup demonstrating the secretary agent configuration:

```python
from just_agents.router.secretary_agent import SecretaryAgent

# Initialize secretary with specific configuration
secretary = SecretaryAgent(
    autoload_from_yaml=False,
    llm_options=your_llm_options,
    extra_dict={
        "personality_traits": "Agent's personality traits go here",
    }
)

# Secretary can update its profile and routing rules
info = secretary.get_info(secretary)
to_populate = secretary.get_to_populate(secretary)
secretary.update_profile(secretary, info, to_populate)

# Save configuration for future use
secretary.save_to_yaml()
```

The secretary can then use this configuration to determine which specialized agent (e.g., a manager, researcher, or technical expert) should handle incoming requests.

## Configuration

Agents can be configured using YAML files, which specify:
- Agent roles and responsibilities
- Routing rules and conditions
- Model preferences
- Custom personality traits

See the tests directory for complete examples of router configuration and usage.
just-agents-web 0.8.9
Just Agents - Web. It allows runing openai API for the agent in the browser.
License: MIT
Requires Python: <3.15,>=3.10
Keywords: python, llm, web, agents, AI

# just-agents-web

A web API wrapper for just-agents that provides OpenAI-compatible endpoints. This package allows you to expose just-agents functionality through a REST API that follows OpenAI's API conventions, making it easy to integrate with existing applications that use OpenAI's API format.

## Installation

```bash
pip install just-agents-web
```

## Features

- 🔄 OpenAI-compatible REST API endpoints
- 🤖 Wrap any just-agents agent as an API service
- 🔌 Drop-in replacement for OpenAI API clients
- 🛠️ Built on just-agents-core

## Dependencies

- just-agents-core
- FastAPI
- pydantic

## Quick Start

The project subpublish run-agent script, so you can run any agent yaml by running:

```bash
run-agent path/to/agent.yaml
```

You can also do it with few lines of python code:
```python
from just_agents.web.run_agent import run_agent_server

run_agent_server(Path("agent_profiles.yaml"))
```

We also provide AgentRestAPI class that you can extend and add your methods to agent endpoint.
just-agents-coding 0.8.9
Just Agents - Coding Components
License: MIT
Requires Python: <3.15,>=3.10

# just-agents-coding

A submodule of just-agents focused on code generation and execution capabilities.

## Overview

just-agents-coding provides secure code execution environments and tools for LLM-powered coding agents. It enables safe code generation and execution through containerized environments, protecting your system while allowing AI agents to write and test code.

## Key Features

- 🔒 Secure code execution through isolated containers
- 🐳 Multiple specialized containers:
  - Standard sandbox for general Python code
  - Biosandbox for bioinformatics tasks
  - Websandbox for web-related code
- 📁 Simple I/O management with mounted `/input` and `/output` directories
- 🔍 Code execution monitoring and logging

## Quick Start

```bash
pip install just-agents-coding
```

## Usage Example

```python
from just_agents.base_agent import BaseAgent
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize agent from configuration
agent = BaseAgent.from_yaml("SimpleCodeAgent", file_path="path/to/coding_agents.yaml")

# Execute code through the agent
result = agent.query("""
Get FGF2 human protein sequence from uniprot using biopython.
As a result, return only the sequence
""")

print(result)
```

## Container Types

### Standard Sandbox
- General Python code execution
- Basic Python packages pre-installed
- Isolated from host system

### Biosandbox
- Specialized for bioinformatics tasks
- Includes common bio packages (Biopython, etc.)
- Safe handling of biological data

### Websandbox
- Web development and testing
- Network access controls
- Common web frameworks available

## Security Features

- Root access disabled in containers
- Resource usage limits
- Network isolation
- Temporary file system
- Controlled package installation

## Documentation

For more detailed documentation and examples, visit:
- [Basic Usage Tutorial](examples/notebooks/03_coding_agent.ipynb)
just-agents-tools 0.8.9
Just Agents - Tools Components
License: MIT
Requires Python: <3.15,>=3.10

# just-agents-tools

Part of [just-agents](https://github.com/longevity-genie/just-agents) - a lightweight, straightforward library for LLM agents that focuses on simplicity over unnecessary abstractions. While other libraries often over-engineer LLM interactions, just-agents keeps things simple and transparent, treating LLM interactions primarily as string operations with clear templating.

## Overview

The tools subpackage aims to provide useful, commonly needed functionalities that can be easily integrated with just-agents, while maintaining:
- 🎯 Simplicity first - no over-engineering
- 📝 Clear, readable implementations
- 🔧 Easy integration with just-agents
- 🚫 No unnecessary abstractions or dependencies

## Status

🚧 This subpackage is currently under development. Tools will be added based on common use cases and community needs.

## Contributing

If you have ideas for useful tools that could benefit the just-agents ecosystem, feel free to contribute! Remember to keep implementations simple and focused.
sdg8193_rekor 0.1.0
A command-line tool for querying and verifying entries in a Rekor transparency log. This tool allows you to fetch log entries, verify inclusion proofs, and check the consistency of the log's Merkle tree.
License: MIT
Requires Python: <4.0,>=3.10

# Python Rekor Verifier

A command-line tool for querying and verifying entries in a Rekor transparency log. This tool allows you to fetch log entries, verify inclusion proofs, and check the consistency of the log's Merkle tree.

## Description

This project provides a client to interact with a Rekor server (e.g., `https://rekor.sigstore.dev`).

Key features include:
- Fetching log entries by index.
- Verifying artifact signatures against public keys from log entries.
- Performing inclusion proof verification to confirm an entry is in the log.
- Verifying consistency between an old and new tree state.

## Installation

1.  Clone the repository:
    ```bash
    git clone https://github.com/sdg8193/Software-Supply-Chain-HW-1.git
    cd python-rekor-monitor-template
    ```

2.  Install the required dependencies:
    ```bash
    pip install poetry
    poetry install
    ```

## Usage

The tool is operated via the command line.

### Get Latest Checkpoint

Fetch the latest signed tree head (checkpoint) from the Rekor server.
```bash
python main.py --checkpoint
```

### Verify Inclusion

Verify that an artifact is included in the log at a specific index. You need the log index and the path to the original artifact.

```bash
python main.py --inclusion <LOG_INDEX> --artifact <PATH_TO_ARTIFACT>
```

**Example:**
```bash
python main.py --inclusion 12345 --artifact ./my-file.txt
```

### Verify Consistency

Verify that a previously known checkpoint is consistent with the latest checkpoint. You need the `treeID`, `treeSize`, and `rootHash` from the old checkpoint.

```bash
python main.py --consistency --tree-id <TREE_ID> --tree-size <OLD_TREE_SIZE> --root-hash <OLD_ROOT_HASH>
```

**Example:**
```bash
python main.py --consistency --tree-id 238498... --tree-size 1000 --root-hash abcdef123...
```

### Debug Mode

For more verbose output for any command, use the `--debug` or `-d` flag.
```bash
python main.py --checkpoint --debug
```
tgeffect 1.4.4
Library for easy access to Telegram message effects
License: MIT
Requires Python: >=3.7

# tgeffect

tgeffect is a Python library that provides easy access to Telegram message effects (effect IDs).
It simplifies working with Telegram message effects and is fully compatible with aiogram.

Features
Provides constants for all standard Telegram message effects

Organizes effects by mood categories: Positive, Negative, Sad, Funny, Neutral

Easy to integrate with Telegram bots using aiogram

Type hints support for better development experience

Installation

```bash
pip install tgeffect
```

# Quick Start

```python
from tgeffect import MessageEffect
from aiogram import Bot, Dispatcher, Router
from aiogram.types import Message

router = Router()

@router.message()
async def handle_message(message: Message):
    # Send message with party effect
    await message.answer("Hello! 🎉", message_effect_id=MessageEffect.Party)

    # Send message with fire effect
    await message.answer("This is awesome! 🔥", message_effect_id=MessageEffect.Fire)

    # Send message with heart effect
    await message.answer("I love this! ❤️", message_effect_id=MessageEffect.Heart)
```

# All Available Effects (Usage Examples)

```python
MessageEffect.Positive.Like        # 👍
MessageEffect.Positive.Heart       # ❤️
MessageEffect.Positive.Fire        # 🔥
MessageEffect.Positive.Party       # 🎉
MessageEffect.Positive.Love        # 🥰
MessageEffect.Positive.Smiling     # 🙂
MessageEffect.Positive.Clap        # 👏
MessageEffect.Positive.StarEyes    # 🤩
MessageEffect.Positive.OkayHand    # 👌
MessageEffect.Positive.Whale       # 🐋
MessageEffect.Positive.BurningHeart # ❤️‍🔥
MessageEffect.Positive.Hundred     # 💯
MessageEffect.Positive.Laughing    # 🤣
MessageEffect.Positive.WinnerCup   # 🏆
Negative Effects
```

```python
MessageEffect.Negative.Dislike     # 👎
MessageEffect.Negative.Angry       # 🤬
MessageEffect.Negative.BoomHead    # 💥
MessageEffect.Negative.Heartbreak  # 💔
MessageEffect.Negative.Clown       # 🤡
MessageEffect.Negative.Zap         # ⚡
```

```python
MessageEffect.Sad.Crying           # 😢
MessageEffect.Sad.Vomit            # 🤮
MessageEffect.Sad.Yawn             # 😪
MessageEffect.Sad.Confused         # 😕
MessageEffect.Sad.BlackMoonSmile   # 🌑
```

```python
MessageEffect.Funny.Poop           # 💩
MessageEffect.Funny.Hotdog         # 🌭
MessageEffect.Funny.Banana         # 🍌
MessageEffect.Funny.Clown          # 🤡
MessageEffect.Funny.Laughing       # 🤣
Neutral Effects
```

```python
MessageEffect.Neutral.ThinkingHead # 🤔
MessageEffect.Neutral.Please       # 🙏
MessageEffect.Neutral.PeacePigeon  # 🕊️
```

# Requirements

`Python 3.7+`
`aiogram 3.x`

# License

`MIT License`
dirigo-ni-digitizer 0.1.0
Plugin to use NI S- and X-series devices as digitizers in Dirigo.
License: MIT
Requires Python: >=3.10

# dirigo-ni-digitizer

`dirigo-ni-digitizer` provides a National Instruments (NI-DAQmx)–based implementation of the `Digitizer` interface from [Dirigo](https://dirigo.readthedocs.io/). It allows NI X-series and S-series DAQ boards to be used as digitizers within Dirigo acquisition workflows (e.g. galvo–galvo scanning, analog and photon-counting).

> **Note**  
> This is a hardware plugin for Dirigo and is not intended to be used as a standalone library. 

![PyPI](https://img.shields.io/pypi/v/dirigo-ni-digitizer)


---

## Installation
First install the NI-DAQmx drivers from official NI channels. Then, inside your Python environment (e.g. a conda environment), run:

```bash
pip install dirigo-ni-digitizer
```

It is recommended to verify that your NI device is recognized in NI MAX or the Hardware Configuration Utility before using this plugin.


## Legal Disclaimer
This library is provided "as is" without any warranties, express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. The authors are not responsible for any damage to hardware, data loss, or other issues arising from the use or misuse of this library. Users are advised to thoroughly test this library with their specific hardware and configurations before deployment.

This library depends on the NI-DAQmx API and its associated drivers, which must be installed and configured separately. This library interacts with the NI-DAQmx API through the officially supported [nidaqmx Python wrappers](https://nidaqmx-python.readthedocs.io/). Compatibility and performance depend on the proper installation and operation of these third-party components.

This library is an independent implementation based on publicly available documentation from National Instruments. It is not affiliated with, endorsed by, or officially supported by National Instruments.

Use this library at your own risk. Proper operation of hardware and compliance with applicable laws and regulations is the sole responsibility of the user.

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.