semvec/pypi-packages huggingface dataset:
llama-index-tools-google 0.6.2
llama-index tools google integration
Requires Python: <4.0,>=3.9
Keywords: email, gmail

# LlamaIndex Tools Integration: Google

### Provides a set of tools to interact with Google services.

- you need to enable each of the below services in your google cloud console, under a same API key for a service, in
  order to use them.

### Quick Start:

```python
# pip install llama-index-tools-google
from llama_index.tools.google import GmailToolSpec
from llama_index.tools.google import GoogleCalendarToolSpec
from llama_index.tools.google import GoogleSearchToolSpec
```

#### [custom search service](https://developers.google.com/custom-search/v1/overview)

```python
google_spec = GoogleSearchToolSpec(key="your-key", engine="your-engine")
```

- `key` collected from your service console
- `engine` which represents the search engine to use, you can create a custom search
  engine [here](https://cse.google.com/cse/all)

#### [calendar read, create]()

- requires OAuth 2.0 credentials, you can create them [here](https://console.developers.google.com/apis/credentials)
- store oAuth`credentials.json` in the same directory as the runnable agent.
- you will need to manually approve the Oath every time this tool is invoked

#### [gmail read, create]()

- same as calendar

### known defects

- the calendar tool create is not able to generate an event if the agent is not able to infer the timezome
clickpesa 1.0.0
A Python library for integrating with ClickPesa payment gateway API
Requires Python: >=3.8
Keywords: api, clickpesa, mobile-money, payment, payments, tanzania, ussd

# ClickPesa Python SDK

A comprehensive Python library for integrating with the ClickPesa payment gateway API. This library provides easy-to-use methods for processing mobile money payments in Tanzania.

## Features

- **Complete API Coverage**: All ClickPesa USSD API endpoints supported
- **Type Safety**: Full type hints and data models
- **Error Handling**: Comprehensive exception handling with specific error types
- **Token Management**: Automatic JWT token generation and refresh
- **Easy Integration**: Simple, intuitive interface

## Project Status:
- [x] Authorization
- Payments:
  - [x] USSD
  - [ ] Card
  - [x] Queries
- Payouts:
  - [ ] Mobile
  - [ ] Bank
  - [ ] Queries
- [ ] Billpay
- [ ] Checkout Link
- [ ] Payout Link
- Account:
  - [ ] Retrieve Account Balance
  - [ ] Retrieve Account Statement
- [ ] Exchange Rates

## Installation

```bash
pip install clickpesa
```

## Quick Start

```python
from clickpesa import ClickPesaClient, Currency

# Initialize the client
client = ClickPesaClient(
    client_id="your_client_id",
    api_key="your_api_key"
)

# Preview available payment methods
preview = client.preview_ussd_push(
    amount="1000",
    currency=Currency.TZS,
    order_reference="ORDER123",
    phone_number="255712345678"
)

# Initiate payment
transaction = client.initiate_ussd_push(
    amount="1000",
    currency=Currency.TZS,
    order_reference="ORDER123",
    phone_number="255712345678"
)

# Check payment status
status = client.query_payment_status("ORDER123")
print(f"Payment status: {status['status']}")
```

## API Methods

### Authentication
- Automatic JWT token generation and management
- Token refresh when expired

### Payment Operations
- `preview_ussd_push()` - Preview payment and get available methods
- `initiate_ussd_push()` - Initiate USSD push payment
- `query_payment_status()` - Check single payment status
- `query_all_payments()` - Query multiple payments with filters

### Convenience Methods
- `get_payment_methods()` - Get available payment methods
- `check_payment_completed()` - Simple boolean check for payment completion

## Error Handling

The library provides specific exception types for different error scenarios:

```python
from clickpesa import (
    ClickPesaAuthError,      # Authentication errors
    ClickPesaValidationError, # Request validation errors
    ClickPesaNotFoundError,  # Resource not found errors
    ClickPesaAPIError        # General API errors
)

try:
    client.initiate_ussd_push(...)
except ClickPesaValidationError as e:
    print(f"Invalid request: {e.message}")
except ClickPesaAuthError as e:
    print(f"Authentication failed: {e.message}")
```

## Examples

See the `examples/` directory for complete usage examples:

- `simple.py` - Basic usage example
- `complete_flow.py` - Full payment processing workflow with monitoring

## Requirements

- Python 3.8+
- requests >= 2.25.0
- typing-extensions >= 4.0.0

## License

MIT License - see LICENSE file for details.
pypft 0.0.4
Polar Fourier Transform for Reconstruction of Polar MR images
Requires Python: >=3.13
Keywords: Hankel Transform, MRI, PFT, Polar MRI

# PyPFT
Polar Fourier Transform for Reconstruction of Polar MR images in Python using Numpy

Assuming you have raw kspace data in polar coordinates $F\left( {\rho ,\varphi } \right)$, if you want to reconstruct the image in the spatial domain with polar coordinates $f\left( {r,\theta } \right)$, you can follow these steps:

$F\left( {\rho ,\varphi } \right)\mathop  \leftrightarrow \limits^{FF{T_\varphi }} {F_n}\left( \rho  \right)\mathop  \leftrightarrow \limits^{{H_n}} {f_n}\left( r \right)\mathop  \leftrightarrow \limits^{IFF{T_\theta }} f\left( {r,\theta } \right)$

Meaning that you need to take two FFTs and one Hankel Transform. FFT is already implemented in `numpy.fft.fft`. However, hankel transform is not implemented. Also, in general, there is no package to handle this type of data natively in Python. This package serves as a toolkit to reconstruct polar MR images using PFT and handle the images after that.

Based on:

    Golshani, S., & Nasiraei‐Moghaddam, A. (2017). Efficient radial tagging CMR exam: A coherent k‐space reading and image reconstruction approach. Magnetic resonance in medicine, 77(4), 1459-1472. https://doi.org/10.1002/mrm.26219

## Dependencies

```"numpy>=2.1"
"matplotlib>=2.0",
"joblib>=1.5",
"opencv-python>=4.12",
"platformdirs>=4.4",
"scipy>=1.16"
```

## Installing

Optional: Create a conda environment
```
conda create -n PyPFT python=3.13
```

Then, once the environment is activated, install it using pip

```
pip install pypft
```

You can run a sample test with this command:

```
python -m pypft test
```
acme-mgmtserver 0.5.0
Deprecated: software has been renamed to 'macen'
Requires Python: >=3.10
Keywords: acme, server, client, proxy, letsencrypt

ACME Management Server (ACMEMS): Now **"Macen"**
================================================

**Deprecated: The software has been rename to ["Macen"](https://github.com/mswart/macen)! Please, update to that one to receive future updates.**

[![PyPI version](https://img.shields.io/pypi/v/acme-mgmtserver.svg)](https://pypi.python.org/pypi/acme-mgmtserver) [![Python Versions](https://img.shields.io/pypi/pyversions/acme-mgmtserver.svg)](https://pypi.python.org/pypi/acme-mgmtserver) [![PyPi Status](https://img.shields.io/pypi/status/acme-mgmtserver.svg)](https://pypi.python.org/pypi/acme-mgmtserver)


[LetsEncrypt](https://letsencrypt.org) supports issuing free certificates by communication via ACME - the Automatically Certificate Management Evaluation protocol.

This tools is yet another ACME client ... but as a client/server model.


## Why yet another ACME client

Some aspects are special:

* **ACME handling can be put into own VM / container ...**: The server can be placed into an own VM, container, network segment to limit the security risk on compromised systems.
* **Only the server requires all the ACME dependencies**: The clients require only a SSL tool like OpenSSL and a HTTP client like wget or curl, no python, no build tools. Python with python-acme and its dependencies (PyOpenSSL, Cryptography, ...) is only needed for the server.
* **Supports distributed web servers**: All `.well-known/acme-challenges` requests for all domains can be served directly by the server. This makes it easy to validate domains when using multiple web server in distributed or fail-over fashion by forwarding all `.well-known/acme-challenges` requests.
* **Only the server needs the ACME account information**: It is not that security relevant, but only the ACME Management Server needs access to the account information / key for the ACME server like LetsEncrypt.
* **Caching CSR signs**: The returned signed certificate of a CSR is cached until the certificate is nearly expired (per default two week). If two machines have manual shared a key and CSR and they reusing both, they will both get from ACMEMS the same certificate back.

## License

GPL License

Copyright (c) 2015-2025, Malte Swart
pytest-google-cloud-storage 1.1.2
Pytest custom features, e.g. fixtures and various tests. Aimed to emulate Google Cloud Storage service
Requires Python: >=3.11

# Introduction
Pytest custom features, e.g. fixtures and various tests. Aimed to emulate Google Cloud Storage service

## Requirements / Resources
- Docker
- [fsouza/fake-gcs-server](https://github.com/fsouza/fake-gcs-server) Emulates Google Cloud Storage
- Python >= 3.11
- Unix/MacOS environment

# Usage
The project involves the development of a custom pytest plugin that emulates the Google Cloud Storage (GCS) service to support streamlined testing workflows.

It is built on top of the original [docker image](https://github.com/fsouza/fake-gcs-server) that handles natively [google-cloud-storage](https://github.com/googleapis/python-storage) functionality,
with the project adding the necessary internal configuration to integrate seamlessly with Polars.

Originally designed to validate [Polars DataFrame](https://github.com/pola-rs/polars) read/write operations in a simulated remote environment,
the plugin enables efficient testing without relying on actual cloud infrastructure.

This setup allows for comprehensive integration testing that closely mirrors real-world cloud interactions.

## Run the emulator manually
```bash
# If you intend to run the image without passing by pytest
docker run -v /tmp/data:/data -d -p 9023:9023 --name storage_emulator fsouza/fake-gcs-server -port 9023 -scheme http -backend memory -public-host 127.0.0.1:9023 -external-url http://127.0.0.1:9023 -filesystem-root /storage
```
The parameters are exactly the same as the docker command in the ``plugin.py`` file.

# Linter

Ruff is the default Python linter used in the project.

If you want to check it, just run ``ruff check``.

All ruff configuration are stored in the ``pyproject.toml`` file.

## The ``check`` command can be added as a pre-commit hook
If by any mean you forget to check the syntax of your code before committing it,
the ``.pre-commit-config.yaml`` will call ``ruff check``.
This avoids unnecessary commits that correct the fact that you forgot to apply the command.

```bash
# Install pre-commit
python3 -m pip install pre-commit
# Install ruff pre-commit in git correct path 
python3 -m pre-commit install
```

# How to test the plugin
Under the folder ``tests`` you'll find common and small tests used to give you the possibility and the usage you can have.


# Appendix

Below, find attached 

* Additional resources that helped building this plugin:
    * Existing cloud storage emulator
      - https://github.com/oittaa/gcp-storage-emulator
    * Github conversation
      - https://github.com/apache/arrow-rs/issues/5263
    * Github code
      - https://github.com/pola-rs/polars/blob/2db0ba608b223a014bba5e10d7b82505898798ed/docs/releases/upgrade/0.20.md?plain=1#L502
      - https://docs.rs/object_store/0.12.0/object_store/gcp/struct.GoogleCloudStorageBuilder.html
      - https://github.com/fsspec/gcsfs/blob/1543ab4fcc4b17fcaa680abab0e93fed33980e21/gcsfs/core.py#L161
    * Similar services relying on other cloud provider
      - https://www.localstack.cloud/
      - https://min.io/