semvec/pypi-packages huggingface dataset:
blnk-chat 0.2.0
A powerful terminal-based chat application for seamless interaction with multiple AI providers
Requires Python: >=3.11
Keywords: ai, anthropic, chat, cli, gemini, openai

# blnk

A powerful terminal-based chat application for seamless interaction with multiple AI providers.

[![PyPI version](https://badge.fury.io/py/blnk.svg)](https://badge.fury.io/py/blnk)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Features

- Multi-provider support (OpenAI, Anthropic, Google Gemini)
- Rich CLI interface with markdown formatting
- Dynamic model switching and API selection
- MCP integration for advanced reasoning
- Streaming responses with progress indicators
- Command system with help documentation
- Configurable setup with environment management

## Installation

```bash
pip install blnk-chat
```

Requires Python 3.13 or higher.

## Quick Start

1. Install blnk:
```bash
pip install blnk-chat
```

2. Run the setup command:
```bash
blnk
/setup
```

3. Configure your API providers and settings following the prompts.

## Usage

Start blnk:
```bash
blnk
```

### Available Commands

- `/help` - Show help message
- `/apis` - List available AI providers
- `/use <api>` - Switch to specified AI provider
- `/model-list` - Show available models for current/all providers
- `/switch-model` - Switch to a different model for current provider
- `/tools` - List available MCP tools
- `/exit` - Exit the application

### Examples

```bash
/use anthropic                               # Switch to Anthropic provider
/switch-model claude-3-5-sonnet-20241022     # Switch to Claude 3 model
/tools                                       # Show available tools
```

## Configuration

blnk-chat uses environment variables for API keys. Create a `.env` file in your project directory:

```env
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GOOGLE_API_KEY=your_google_key
```

## Contributing

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

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

- Built with [MCP-Reasoner](https://github.com/Jacck/mcp-reasoner) for advanced reasoning capabilities
- Thanks to all [contributors](CONTRIBUTORS.md)

## Author

[frgmt0](https://github.com/frgmt0) - frgmt_@frgmt.xyz
qubit-simulator 0.1.1
A simple quantum circuit simulator.

# Qubit Simulator

A simple yet flexible statevector-based quantum circuit simulator for Python. It supports common single-, two-, and three-qubit gates (including parameterized gates), measurement (shot-based sampling), state resetting, and basic circuit visualization.

## Features

- **Statevector Simulation**: Maintains a complex-valued statevector of size ( 2^n ).
- **Common Gates**: X, Y, Z, H, S, T, plus multi-qubit gates like CNOT, SWAP, Toffoli, Fredkin, etc.
- **Parameterized Gates**: General single-qubit rotation ( U(θ, φ, λ) ).
- **Controlled Gates**: Automatically construct controlled versions of single-qubit gates.
- **Circuit Visualization**: Generate a diagram of applied operations with `.draw()`.
- **Measurement**: Returns shot-based measurement outcomes from the final state.
- **Lightweight**: Only requires [NumPy](https://numpy.org). For plotting, install optional [matplotlib](https://matplotlib.org).

## Installation

Install Qubit Simulator via pip:

```bash
pip install qubit-simulator[visualization]
```

## Usage

### Initializing the Simulator

Create a simulator with a specified number of qubits:

```python
from qubit_simulator import QubitSimulator

sim = QubitSimulator(num_qubits=2)
```

### Applying Gates

Apply various quantum gates to the qubits:

```python
sim.h(0)      # Hadamard gate
sim.t(0)      # π/8 gate
sim.cx(0, 1)  # Controlled-Not gate
```

### Custom Gates

Define and apply custom gates using angles:

```python
sim.u(1.05, 1.57, 3.14, 1)  # Arbitrary single-qubit gate
```

### Circuit Drawing

Get a drawing of the circuit:

```python
sim.draw()
```

![Circuit Drawing](https://github.com/user-attachments/assets/2e6dbbc3-39e0-4d4f-8c43-c6f2ba83e121)

### Measurements

Measure the state of the qubits:

```python
print(sim.run(shots=100))
```

```plaintext
{'000': 49, '001': 1, '100': 1, '101': 49}
```

### Statevector Plot

Show the amplitude and phase of all quantum states:

```python
sim.state()
```

![Statevector Bar Chart](https://github.com/user-attachments/assets/f883b77f-1dc5-4236-8aed-0d67f8305e12)

## Testing

Tests are included in the package to verify its functionality and provide more advanced examples:

```shell
python3 -m pytest tests/
```

## License

This project is licensed under the MIT License.
hamcrest-proto 0.0.6
Hamcrest matchers for protobufs
Requires Python: >=3.7

# hamcrest-proto

[Hamcrest](https://pypi.org/project/PyHamcrest/) matchers for [Protocol Buffers](https://protobuf.dev/) in Python.

This is forked from [proto-matcher](https://pypi.org/project/proto-matcher/) which was no longer receiving updates and which was itself based on [MessageDifferencer](https://developers.google.com/protocol-buffers/docs/reference/cpp/google.protobuf.util.message_differencer) and [EqualsProto](https://github.com/google/googletest/issues/1761) googletest matcher.

## API

This packages provides the following proto-related [matchers](https://pyhamcrest.readthedocs.io/en/latest/library.html):

### `equals_proto`

```python
equals_proto(message: Union[Message, str])
```
Test the argument equals the given protobuf message.

### `approximately`

```python
approximately(proto_matcher: Matcher[Message],
              float_margin: Optional[float] = None,
              float_fraction: Optional[float] = None)
```
Test the argument equals the given protobuf message, while comparing any float field using approximation.

### `ignoring_field_paths`

```python
ignoring_field_paths(field_paths: Set[Tuple[str, ...]],
                     matcher: _ProtoMatcher)
```
Test the argument equals the given protobuf message, while ignoring those fields specified in the field paths.


### `ignoring_repeated_field_ordering`

```python
ignoring_repeated_field_ordering(proto_matcher: Matcher[Message])
```
Test the argument equals the given protobuf message, ignoring the ordering of any repeated field.


### `partially`

```python
partially(proto_matcher: Matcher[Message])
```
Test the argument partially equals the given protobuf message, i.e. if a field is in the argument but not in the expected message, it's ignored in the comparsion.