semvec/pypi-packages huggingface dataset:
blastai 0.1.6
Browser-LLM Auto-Scaling Technology
Requires Python: >=3.11

<div align="center">
  <img src="docs/assets/blast_icon_only.png" width="200" height="200" alt="BLAST Logo">
</div>

<p align="center" style="font-size: 24px">A high-performance serving engine for web browsing AI.</p>

<div align="center">

[![Website](https://img.shields.io/badge/blastproject.org-FFE067)](https://blastproject.org)
[![Documentation](https://img.shields.io/badge/Docs-FFE067)](https://docs.blastproject.org)
[![Discord](https://img.shields.io/badge/Discord-FFE067)](https://discord.gg/NqrkJwYYh4)
[![Twitter Follow](https://img.shields.io/twitter/follow/realcalebwin?style=social)](https://x.com/realcalebwin)

</div>

<div align="center">
  <img src="website/assets/blast_ui_gif.gif" alt="BLAST UI Demo" width="80%">
</div>

## ❓ Use Cases

1. **I want to add web browsing AI to my app...** BLAST serves web browsing AI with an OpenAI-compatible API and concurrency and streaming baked in.
2. **I need to automate workflows...** BLAST will automatically cache and parallelize to keep costs down and enable interactive-level latencies.
3. **Just want to use this locally...** BLAST makes sure you stay under budget and not hog your computer's memory.

## 🚀 Quick Start

```bash
pip install blastai && blastai serve
```

```python
from openai import OpenAI

client = OpenAI(
    api_key="not-needed",
    base_url="http://127.0.0.1:8000"
)

# Stream real-time browser actions
stream = client.responses.create(
    model="not-needed",
    input="Compare fried chicken reviews for top 10 fast food restaurants",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta if " " in event.delta else "<screenshot>", end="", flush=True)
```

## ✨ Features

- 🔄 **OpenAI-Compatible API** Drop-in replacement for OpenAI's API
- 🚄 **High Performance** Automatic parallelism and prefix caching
- 📡 **Streaming** Stream browser-augmented LLM output to users
- 📊 **Concurrency** Out-of-the-box support many users with efficient resource management

## 📚 Documentation

Visit [documentation](https://docs.blastproject.org) to learn more.

## 🤝 Contributing

Awesome! See our [Contributing Guide](https://docs.blastproject.org/development/contributing) for details.

## 📄 MIT License

As it should be!
password-check 0.0.1
Checks whether passwords meet security criteria.
Requires Python: >=3.7

# password-check

A simple Python package to check if passwords meet security criteria.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name


```bash
pip install password-check
```

## Author
Larissa Batista

## License
[MIT](https://choosealicense.com/licenses/mit/)
checkers-truce-simple 1.1
checkers truce simple
Keywords: checkers, truce, simple, cts, checkerstrucesimple

<img src="https://files.catbox.moe/iwamtq.png" alt="checkers truce simple">

https://purplr.itch.io/cts but it's a python module

installs the `checkers-truce-simple` command-line tool when installed.  
if it doesn't work you can use the `checkers_truce_simple.cts()` function.
dbt-docs-publisher 0.1.0
A CLI tool for publishing dbt docs to Azure Blob Storage
Requires Python: >=3.7

# dbt-docs-publisher

A CLI tool for publishing dbt documentation to Azure Blob Storage.

## Features

- Automatically runs `dbt docs generate --static`
- Finds generated docs in temp directories
- Uploads all documentation files to Azure Blob Storage
- Organizes files by environment (dev, prod, etc.)
- Provides info on enabling static website hosting in Azure

## Installation

```bash
pip install dbt-docs-publisher
```

For use in Databricks:

```bash
pip install dbt-docs-publisher[databricks]
```

## Usage

```bash
ddp send-report \
  --profile-target=dev \
  --env=dev \
  --azure-container-name=dbt-docs \
  --azure-connection-string="your_azure_connection_string" \
  --update-bucket-website
```

### Arguments

- `--profile-target`: The dbt profile target to use
- `--env`: Environment name (dev, prod, etc.) - used for organizing files in storage
- `--azure-container-name`: Azure Blob Storage container name
- `--azure-connection-string`: Azure Blob Storage connection string
- `--update-bucket-website`: (Optional) Display information about enabling static website hosting

## Using in Databricks

Add to your Databricks job:

```yaml
libraries:
  - pypi:
      package: dbt-docs-publisher[databricks]
commands:
  - ddp send-report --profile-target=${bundle.target} --env=prod --azure-container-name=dbt-docs --azure-connection-string="$dl_conn_str"
```

## Development

### Setup

```bash
git clone https://github.com/yourusername/dbt-docs-publisher.git
cd dbt-docs-publisher
pip install -e ".[dev]"
```

### Building and Publishing

```bash
# Build the package
python setup.py sdist bdist_wheel

# Publish to PyPI
twine upload dist/*
```

## License

MIT
code-profilers 1.3.1
# Introduction
Keywords: python, profilers, profiler

# Introduction
This is a package for profiling your code, and use it to better understand what is happening in your code and debug better.
This is availale to use in any python code (no framework specific).


# Profilers
There is `Main Profiler` Which will register all profilers and responsible for handling issues and reporting info.

### Currently Supported Profilers
* MySQLProfiler

# Integrations
For the ease of development, we added some integrations which will take the `Main Profiler` and handle the integration with other frameworks.
Also you could use profilers without integrations, but you will write more code.


### Currently Supported Integrations
* Flask
    * It is used for integrating profilers with flask with only few code


# Examples
This is an example for using MySQL Profiler With Flask
```python
from flask import Flask

from code_profilers.main_profiler import MainProfiler
from code_profilers.profilers.mysql.profiler import MySQLProfiler
from code_profilers.integrations.flask import FlaskIntegration

app = Flask(__name__)

profiler = MainProfiler()
profiler.register_profiler(MySQLProfiler())
FlaskIntegration(app, profiler)
```
Then you are ready to go and test your code
airc-extract 0.2.3
Extracts AIRC data from DICOM files and uploads to SQLite Database
Requires Python: >=3.11

# AI-Rad Companion Chest CT Extractor

This is a python library and command line tool for extracting the results of Siemens' AI-Rad companion Chest CT software into a relational database.  
*NOTICE: Command line tool only for use with an appropriate DicomConquest PACS*  

To install, simply use  
```bash
pip install airc_extract
```

This will install the package and the two necessary command line programs to your python environment. 
## Usage
### Python API
If you simply want to use the extraction method stored
in the `AIRCReport` class, you can import and use it in any python script with
```python
from airc_extract.airc_report import AIRCReport
# This is the list of structured report (SR) dicoms that make up the AIRC Chest CT output
report_dicoms = ['dcm1.dcm', 'dcm2.dcm', ...]
report = AIRCReport(report_dicoms)
report.extract_report()  # This is the method to pull the data
print(report.report_data)  # A dictionary containing the results
```
### Command Line
If you are using a [DicomConquest](https://github.com/marcelvanherk/Conquest-DICOM-Server) server, you can use the two command line tools provided 
in this package to automatically create and update a SQLite database, storing the AIRC results in 6 tables. More information on these tables can be found
[here](https://github.com/idinsmore1/airc_extract/edit/main/src/airc_extract/db_ops.py).  

To start, you will need to run `airc-create-config`.
```bash
airc-create-config \
--dicom-db /path/to/conquest.db3 \ # Required (usually dicomserver/data/dbase/conquest.db3)
--dicom-data-dir /path/to/conquest/data \ # Required (usually dicomserver/data)
--data-db /path/to/output/database.db3 \ # Required. Can NOT be on a network share.
--log-level-term INFO # Terminal logging level \
--log-level-file DEBUG # Log file logging level \
--log-dir . # Directory for log files to be stored
```
This will setup a package `config.ini` file that will be used for extraction, as well as test the connection to the DicomConquest database and the output database. 
It will create a new output database with all necessary tables at the specified path if it does not exist.  

After this, just run 
```bash
airc-extract
```
and all the series not found in the output database will be extracted and inserted into the output database.
test-cts-test-cts 1
test test
Keywords: checkers, truce, simple, cts, checkerstrucesimple

<img src="https://files.catbox.moe/iwamtq.png" alt="checkers truce simple">

https://purplr.itch.io/cts but it's a python module

installs the `checkers-truce-simple` command-line tool when installed.  
if it doesn't work you can use the `checkers_truce_simple.cts()` function.
ainit 0.1.0rc0
Make class instantiation easy with auto-imports
Requires Python: >=3.7

# ainit

Make class instantiation easy with auto-imports

## Installation

```bash
pip install aini
```

## Usage

### aini

**AI** component (or any classes) **in**itialization with auto-imports:

```python
from aini import aini

agent = aini('agno/agent', tools=[aini('agno/tools', 'google')])
```

### aview

View AI component properties:

```python
from aini import aview

# Example usage
ans = agent.run('Compare MCP and A2A')
aview(ans)

# Save to file
aview(ans, to_file='debug/output.yaml')
```
espress-mcp 0.1.0
Add your description here
Requires Python: >=3.12

# espresso-mcp

A MCP Server for the Espresso Android Test Framework, designed to enhance testing capabilities and streamline development workflows.

<a href="https://glama.ai/mcp/servers/@vs4vijay/espresso-mcp">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/@vs4vijay/espresso-mcp/badge" />
</a>

## Installation

- Python 3.x
- uv: `pip install uv`

```bash
uv tool install espresso-mcp
```

## Usage

- On Claude: Add below JSON config to the file `claude_desktop_config.json`

```json
{
  "mcpServers": {
    "terminal": {
      "command": "uv",
      "args": ["pip", "run", "espresso-mcp", "--timeout-ms", "30000"]
    }
  }
}
```

## Available Tools

The following tools are available in the `espresso-mcp` project:

- **list_avds**: List all available Android Virtual Devices (AVDs).
- **list_emulators**: List all running Android Emulators.
- **start_emulator**: Start an Android Emulator by name.
- **kill_emulator**: Kill a specific Android Emulator.
- **dump_ui_hierarchy**: Dump the UI hierarchy of the connected Android device.
- **open_uri**: Open a URI on the connected Android device.
- **list_apps**: List all installed apps on the connected Android device.
- **install_app**: Install an APK on the connected Android device.
- **start_app**: Start a specific app on the connected Android device.
- **stop_app**: Stop a specific app on the connected Android device.
- **uninstall_app**: Uninstall an app from the connected Android device.
- **clear_app_data**: Clear app data for a specific app on the connected Android device.
- **take_screenshot**: Take a screenshot of the connected Android device.
- **record_screen**: Record the screen of the connected Android device for a specified duration.
- **press_button**: Simulate a button press on the connected Android device.
- **type_text**: Type text on the connected Android device.
- **tap**: Simulate a tap on the connected Android device at specific coordinates.
- **swipe**: Perform a swipe gesture in a specific direction on the connected Android device.

## Resources

The following resources are available:

- **config://app**: Retrieve static configuration data.
- **greeting://{name}**: Get a personalized greeting.

---

## Local Setup

- Python 3.x
- uv: `pip install uv`

```bash
# Install
uv install

# Run Dev Mode
uv run mcp dev server.py
```

## Debugging

- Use MCP Inspector

```bash
# Install MCP Inspector
yarn global add @modelcontextprotocol/inspector

# Test MCP Server
yarn run @modelcontextprotocol/inspector python server.py
```

## Testing

```bash
uv run pytest
```

## Publishing

```bash
# Build the package
uv pip install build
python -m build

# Upload to PyPI
uv pip install twine
python -m twine upload dist/*
```

---

### Developement Notes

```bash

uv init espress-mcp

uv add "mcp[cli]"

uv run mcp dev server.py

```
prprogVentas1 0.0.1
Paquete para gestionar ventas, precios, impuestos y descuentos
Requires Python: >=3.7

# Aplicacion de ventas

Este paquete proporciona funcionalidades para gestionar ventas incluyendo el calculo de precios, impuestos y descuentos.

## Instalacion

Puedes instalar el paquete usando:

```bash
pip install .
"
indaleko-registry-service 0.1.0
Semantic registration service for UUID and metadata mapping.
Requires Python: >=3.12

# Registry Service

Standalone semantic registration service for UUID and metadata mapping.

Indaleko is an implementation of the Unified Personal Index service, a means of using metadata to bridge human episodic
memory and traditional storage.  Indaleko uses dynamic data sources, so the purpose of the registration service is:

- To allow dynamically adding services to the system.  Each new service is given a UUID to represent it.
- To separate semantic meaning from database labeling.
  - Every collection (table) in the database has a UUID name.
    The mapping of that name to the UUID is maintained separately from the database where the information is stored.
  - Elements in the schema are UUIDs.
    The mapping of that element to the UUID is maintained separately from the database where the information is stored.
- Each UUID may have optional metadata associated with it.  For example, this can be used to have
  per data type encryption keys to protect sensitive information.  This works because the mapping table is
  small relative to the data and can be protected, even when using public facing services for the database.
- Semantic descriptions need not be limited to a single name.  They can (and should) be provided with a description.
  Indaleko uses these along with LLMs to construct an ontology.  In this way a dynamic system with distributed
  providers can be identified as providing equivalent information (that is, there is a mapping between them, such as
  data providers that keep distance in parsecs and another that keeps it in Angstrom.)
- Semantic labels, which are the identifier used by the service provider, must be unique and once the label->UUID mapping is established it is immutable.  Note that this mapping will vary on a per-installation basis.
- UUIDs can be mapped back to semantic labels, semantic descriptions, and other properties the registry stores.

## Status

### Test Version
[![TestPyPI](https://img.shields.io/badge/TestPyPI-indaleko--registry--service-blue)](https://test.pypi.org/project/indaleko-registry-service/)

### Distribution Version

[![PyPI version](https://badge.fury.io/py/indaleko-registry-service.svg)](https://pypi.org/project/indaleko-registry-service/)

## Installation

Install via uv:
```bash
uv pip install .
```

## Usage

Run the service with the CLI:
```bash
registry-service
```

Or directly with Uvicorn:

```bash
uvicorn registry_service.service:app --host 0.0.0.0 --port 8000
```

## Lookup

To resolve a semantic label to a UUID:

...

## Reverse Lookup

To resolve a UUID back to its semantic identifier, call the `/lookup` endpoint with the `uuid` query parameter:

```bash
curl -X GET "http://localhost:8000/lookup?uuid=<UUID>"
```

Response example:
```json
{
  "uuid": "123e4567-e89b-12d3-a456-426614174000",
  "category": "semantic_label",
  "name": "test_label"
}
```

## Running Tests

Execute the full test suite:
```bash
pytest
```