semvec/pypi-packages huggingface dataset:
pl-viz 0.4.0
Fetch and visualize data from PL.
License: MIT
Requires Python: >=3.10

# prairielearn-viz

`pl_viz` is a Python package designed to simplify data extraction and visualization for courses on PrairieLearn. With its object-oriented design, `pl_viz` makes it easy to fetch data for courses, students, and assessments, and generate insightful visualizations to analyze student performance and assessment outcomes.

## Features
- **Object-Oriented Design**: Includes Course, Student, and Assessment classes for modular and intuitive data handling.
- **Data Extraction**: Fetch student lists, assessment details, and submission scores directly from the PrairieLearn API.
- **Data Visualization**:
    - Boxplots for score distributions across assessments.
    - Histograms to analyze score frequency.
- **Summary Statistics**: Compute mean, median, min, and max scores for assessments.

## Installation

To install the pl_viz package, use the following command:

```python
pip install pl_viz
```

## Usage

You will need a PrairieLearn API token to use this package. Store the token as an environment variable for security:

```bash
export PL_API_TOKEN="your_api_token_here"
```

## Classes Overview

1. `Course`

Represents a PrairieLearn course. Use it to:

- Fetch students and assessments.
- Display summary statistics.
- Generate visualizations.

2. `Student`

Represents an individual student, providing access to their user ID, name, and UID.

3. `Assessment`

Represents an assessment within a course. Fetch submissions and analyze score distributions.

## Contributing

Contributions are welcome! If you’d like to contribute to `pl_viz`, please open an issue or submit a pull request. Ensure you follow the coding standards and add tests for new features.

## License

This project is licensed under the MIT License. See the LICENSE file for details.
superslurp 0.0.1
A parser for SuperU receipts
License: MIT
Requires Python: >=3.12
Keywords: parser, receipt, superu

# superslurp : Super, Sublime, Light, and Unprecedented Receipt Parser

Parser for SuperU receipts. Take the PDF receipt sent by mail as input and return a
json.

Useful when you want to display the instantaneous cheese consumption intensity of your
home in € inside grafana.
pre-commit-html 0.1.5
Format results from pre-commit cmd to HTML file
License: MIT
Requires Python: <4.0,>=3.13

# Pre-Commit Formatter

> Portuguese version [here](docs/README-pt.md)(Link only works on the project page).

This project is designed to run pre-commit hooks and format the results into an HTML file for easy viewing.

## Summary

- [How It Works](#how-it-works)
- [Installation](#installation)
- [Usage](#usage)
- [Project Structure](#project-structure)
- [Templates](#templates)
- [Example](#example)
- [License](#license)
- [Contributing](CONTRIBUTING.md)
- [Code of Conduct](CODE_OF_CONDUCT.md)

## How It Works

1. **Run Pre-Commit Hooks**: The `PreCommitToHTML` class runs the pre-commit hooks using the `pre-commit run --all-files` command.
2. **Parse Output**: The output from the pre-commit hooks is parsed to extract relevant information such as file paths, line numbers, column numbers, and error messages.
3. **Generate HTML**: The parsed information is then formatted into an HTML file using Jinja2 templates. The HTML file includes links to the relevant lines in the source code and references to the documentation for the errors.

## Installation

To use this project, you need to have Python and `pre-commit` installed. You can install the required dependencies using pip:

```sh
poetry install
```

## Usage

To run the pre-commit formatter, execute the following command:

```sh
python -m pre_commit_html
```

This will generate an HTML file named `result_pre_commit.html` in the project directory.

## Project Structure

- `pre_commit_html/__main__.py`: Contains the main function to run the pre-commit formatter.
- `pre_commit_html/__init__.py`: Contains the `PreCommitToHTML` class which handles running the pre-commit hooks and formatting the output.
- `site/templates/`: Contains the Jinja2 templates used to generate the HTML file.

## Templates

The project uses Jinja2 templates to format the HTML output. The templates are located in the `site/templates/` directory and include:

- `code_part.jinja`: Template for formatting code parts.
- `code_error.jinja`: Template for formatting code errors.
- `html_content.jinja`: Template for the overall HTML content.

## Example

Here is an example of how the HTML output might look:

```html
<h3>File: <a href="./path/to/file.py:10:5">path/to/file.py:10:5</a></h3>
<p>
  Error: <a href="https://docs.astral.sh/ruff/rules/#E123">E123</a> Some error
  message
</p>
<pre>
    | Some code part |
</pre>
```

## License

This project is licensed under the [MIT License](./LICENSE).
crewai-adapters 0.1.2
Native adapter support for CrewAI with Model Context Protocol (MCP) integration
License: MIT
Requires Python: >=3.11
Keywords: crewai, mcp, adapters, ai, agents

# CrewAI MCP Adapter

A Python library extending CrewAI's adapter ecosystem with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) integration support and comprehensive tooling for custom agent and tool development.

## Features

- 🔌 Native CrewAI integration and adapter patterns 
- 🛠️ MCP protocol support for tool integration
- 🧩 Easy-to-use interface for extending and creating new adapters
- 📝 Type-safe implementation with Pydantic
- 🔍 JSON Schema validation for tool parameters
- 🚀 Async/await support
- 📊 Detailed execution metadata

## Installation

You can install the package directly from PyPI:

```bash
pip install crewai-adapters
```

Or install from source:

```bash
pip install git+https://github.com/dshivendra/crewai_mcp_adapter.git
```

## Quick Start

```python
from crewai import Agent, Task
from crewai_adapters import CrewAIAdapterClient
from crewai_adapters.types import AdapterConfig

async def main():
    async with CrewAIAdapterClient() as client:
        # Connect to MCP server
        await client.connect_to_mcp_server(
            "math",
            command="python",
            args=["math_server.py"]
        )

        # Create agent with tools
        agent = Agent(
            name="Calculator",
            goal="Perform calculations",
            tools=client.get_tools()
        )

        # Execute task
        task = Task(
            description="Calculate (3 + 5) × 12",
            agent=agent
        )
        result = await task.execute()
        print(f"Result: {result}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
```

## Documentation

For detailed documentation, see:
- [Getting Started Guide](docs/index.md)
- [API Reference](docs/api_reference.md)
- [Examples](docs/examples.md)

## Development

### Prerequisites

- Python 3.11 or higher
- `crewai` package
- `pydantic` package
- `mcp` package

### Install Development Dependencies

```bash
pip install -e ".[test,docs]"
```

### Running Tests

```bash
pytest tests/ -v
```

## Publishing

To publish a new version to PyPI:

1. Update version in pyproject.toml
2. Build the package:
   ```bash
   python -m build
   ```
3. Upload to PyPI:
   ```bash
   python -m twine upload dist/*
   ```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

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