semvec/pypi-packages huggingface dataset:
logpyle 2025.1
Time series logging for Python
Requires Python: >=3.10

# logpyle: Time Series Logging (not just) for Simulation

[![CI](https://github.com/illinois-ceesd/logpyle/workflows/CI/badge.svg)](https://github.com/illinois-ceesd/logpyle/actions?query=workflow%3ACI+branch%3Amain)
[![Documentation Status](https://readthedocs.org/projects/logpyle/badge/?version=latest)](https://logpyle.readthedocs.io/en/latest/?badge=latest)

`logpyle` is a Python package for time series logging (formerly part of the `pytools.log` and `datapyle` packages)
that uses SQLite under the hood and makes it easy to compare multiple runs.

* [Documentation](https://logpyle.readthedocs.io/en/latest/)
wRodaCupom 1.0.0
Automação de agendamento e envio de relatórios de cupons.
Requires Python: >=3.6

# wRodaCupom

Automação de agendamento e envio de relatórios de cupons.

## Funcionalidades
- Agendamento automático de tarefas.
- Envio de relatórios por e-mail.
- Interface gráfica para configuração e execução manual.

## Requisitos
- Python 3.6 ou superior.
- Dependências listadas no arquivo `setup.py`.

## Instalação
1. Clone este repositório.
2. Instale as dependências com `pip install -r requirements.txt`.
3. Execute o aplicativo com `python auto_process.py`.

## Licença
Este projeto está licenciado sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.
pygame-matplotlib 0.5
A matplotlib backend using pygame.
Requires Python: >=3.9
Keywords: backend, matplotlib, plot, pygame

# Pygame Matplotlib Backend

Create plots in pygame.


Note that the library is in an experimental developement stage and not
all features of standard matplotlib backends are implement at the moment.

## Installation
```
pip install pygame-matplotlib
```

## Usage

First you will need to specify that you want to use pygame backend.
```python
# Select pygame backend
import matplotlib
matplotlib.use('pygame')
```

Then you can use matplotlib as you usually do.
```python
# Standard matplotlib syntax
import matplotlib.pyplot as plt
fig, ax = plt.subplots()  # Create a figure containing a single axes.
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])  # Plot some data on the axes.
plt.show()
```

Or you can include the plot in your game using the fact that a ```Figure``` is
also a ```pygame.Surface``` with this backend.
```python
import pygame
import pygame.display

fig, axes = plt.subplots(1, 1,)
axes.plot([1,2], [1,2], color='green', label='test')

fig.canvas.draw()

screen = pygame.display.set_mode((800, 600))

# Use the fig as a pygame.Surface
screen.blit(fig, (100, 100))

show = True
while show:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            # Stop showing when quit
            show = False
    pygame.display.update()
```

Note that if you want to update the plot during the game, you might
need to call ```fig.canvas.draw()``` and ```screen.blit(fig)``` during
the game loop.

See examples in test.py or test_show.py


## How it works in the back

The matplotlib ```Figure``` object is replaced by a ```FigureSurface``` object
which inherits from both ```matplotlib.figure.Figure``` and
```pygame.Surface```.


## Current implementation

Support mainly the basic plotting capabilities.
pointr-cloud-v8-mcp-server 0.1.5
Indoor location assistant using Pointr MCP server to provide QR code navigation for venues.
Requires Python: >=3.13

# Pointr Indoor Location Assistant

This project provides an indoor location assistant powered by the Pointr MCP server. Users can interact with the assistant to get QR code links for directions to specific places or categories (e.g., toilets, restaurants, cafes, entertainment centers) within a venue.

## Features
- Find directions to specific points of interest (POIs) or general categories.
- Generate QR codes for navigation.
- Uses Pointr MCP server for location logic.
- Logs client identifiers and actions to `pointr_agent.log`.

## Usage
1. **Setup Environment**
   - Ensure Python 3.13+ is installed.
   - Install dependencies from `requirements.txt`:
     ```bash
     pip install -r requirements.txt
     ```
   - Configure environment variables in `.env` or via VS Code settings (see `settings.json`).

2. **Run the MCP Server**
   - Start the server:
     ```bash
     python PointrAgent.py
     ```
   - Or use the VS Code MCP integration as configured in `settings.json`.

3. **Interact with the Assistant**
   - Ask for directions (e.g., "Where is the nearest cafe?", "How can I go to the meeting room?").
   - The assistant will respond with a QR code link for navigation.

## File Structure
- `PointrAgent.py`: Main agent logic and MCP tool definitions.
- `app.py`: Example runner for the agent.
- `requirements.txt`: Python dependencies.
- `pointr_agent.log`: Log file for client identifiers and actions.
- `settings.json`: VS Code and MCP server configuration.

## MCP Tools
- `find_exact_poi_from_user_input`: Extracts POI ID from user input.
- `find_exact_category_from_user_input`: Extracts category from user input.
- `generate_qr_code_for_specific_poi`: Generates QR code for a specific POI.
- `generate_qr_code_for_category`: Generates QR code for a category.

## Environment Variables
- `PC_API_URL`: Pointr API endpoint.
- `PC_CLIENT_ID`: Client identifier.
- `PC_CLIENT_SECRET`: Client secret.

## Logging
All client identifiers and tool actions are logged to `pointr_agent.log` for debugging and audit purposes.

## License
MIT

## Publish image for Remote MCP Server

docker build --platform linux/amd64 --no-cache -t pointr-mcp-server:1.0.10 .
docker tag pointr-mcp-server:1.0.10 pointr/swdel-sdt-mcp-server:1.0.10
docker push pointr/swdel-sdt-mcp-server:1.0.10

pip3 install --upgrade --force-reinstall --no-cache-dir -r requirements.txt
python3 -m pointr_cloud_v8_mcp_server.server

1.0.8 > mcp==1.9.3 version
1.0.9 > mcp==1.12.2 version
1.0.10 > mcp==1.12.2 / root. > This is the one works for copilot studio

## Publish to pypi as python as package

pip install build
python3 -m build
python3 -m pip install --upgrade twine
python3 -m twine upload dist/*
better-python-doppler 1.0.0
A simplified and up to date Python SDK for Doppler. Because their current one has stale docs and doesn't provide much IDE support.
Requires Python: >=3.12
Keywords: Doppler, SKD

# Better Python Doppler

Better Python Doppler is a lightweight SDK around the [Doppler API](https://docs.doppler.com/reference). It wraps common API endpoints in simple Python classes and includes typed models for working with secrets.

## Installation

This project currently requires Python 3.12 or newer. Once published to PyPI it can be installed with `pip`:

```bash
pip install better-python-doppler
```

For local development clone the repository and install the dependencies:

```bash
pip install -e .
```

## Quick Start

The example below mirrors `examples/example_secrets.py` and demonstrates basic usage of the SDK. It assumes the environment variables `SERVICE_TOKEN`, `PROJECT_NAME`, `CONFIG_NAME` and `SECRET_NAME` are available.

```python
from better_python_doppler import Doppler

# Create the SDK instance
sdk = Doppler(service_token=os.getenv("SERVICE_TOKEN"))

# List secret names
names = sdk.Secrets.list_names(
    project_name=os.getenv("PROJECT_NAME"),
    config_name=os.getenv("CONFIG_NAME")
)

# Fetch all secrets
secrets = sdk.Secrets.list(
    project_name=os.getenv("PROJECT_NAME"),
    config_name=os.getenv("CONFIG_NAME")
)

# Retrieve a specific secret value
secret_value = sdk.Secrets.get(
    os.getenv("PROJECT_NAME"),
    os.getenv("CONFIG_NAME"),
    os.getenv("SECRET_NAME")
)
print(secret_value.value.raw)
```

## Functionality

The SDK focuses on secrets management via the `Doppler.Secrets` interface defined in `secret.py`. Supported operations include:

- `list` – return detailed information for all secrets in a config.
- `list_names` – fetch only the secret names.
- `get` – retrieve a single secret as a `SecretModel`.
- `update` – update one or more secret values.
- `download` – download secrets in various formats (json, env, yaml, etc.).
- `delete` – delete a secret.
- `update_note` – modify the note on an existing secret.

Under the hood these call lightweight API wrappers located in `src/better_python_doppler/apis`. The project also exposes minimal data models in `src/better_python_doppler/models` such as `SecretModel` and `SecretValue` for convenient type checking.

Authentication is performed with a Doppler service token. You can pass the token directly when creating `Doppler` or load it from an environment variable using the `service_token_environ_name` parameter.

## License

This project is licensed under the Apache 2.0 License. See the [LICENSE](LICENSE) file for details.