semvec/pypi-packages huggingface dataset:
pycaputo 0.10.1
Evaluate fractional integrals and solve fractional ODEs
Requires Python: >=3.10
Keywords: fractional-derivatives, fractional-integrals, quadrature, time-stepping

.. |badge-ci| image:: https://github.com/alexfikl/pycaputo/actions/workflows/ci.yml/badge.svg
    :alt: Build Status
    :target: https://github.com/alexfikl/pycaputo/actions/workflows/ci.yml

.. |badge-pypi| image:: https://badge.fury.io/py/pycaputo.svg
    :alt: PyPI
    :target: https://pypi.org/project/pycaputo/

.. |badge-rtd| image:: https://readthedocs.org/projects/pycaputo/badge/?version=latest
    :alt: Documentation
    :target: https://pycaputo.readthedocs.io/en/latest/?badge=latest

.. |badge-reuse| image:: https://api.reuse.software/badge/github.com/alexfikl/pycaputo
    :alt: REUSE
    :target: https://api.reuse.software/info/github.com/alexfikl/pycaputo

.. |badge-zenodo| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.10996099.svg
    :target: https://doi.org/10.5281/zenodo.10996099

|badge-ci| |badge-pypi| |badge-rtd| |badge-reuse| |badge-zenodo|

pycaputo
========

This library can be used to evaluate fractional integrals and solve fractional ODEs.
It is currently a testbed for various traditional methods, but hopefully
development will continue and it will be a nice flexible library with support
for many different types of fractional derivatives (and other related operators).

It is currently quite far from that goal, so this is **very experimental**.

Development
===========

Links

* `Documentation <https://pycaputo.readthedocs.io/en/latest/>`__
* `Code <https://github.com/alexfikl/pycaputo>`__

Other known libraries for fractional calculus

* `Diffusive-Representation <https://github.com/fmonteghetti/Diffusive-Representation>`__ (MATLAB)
* `FLMM2 <https://www.mathworks.com/matlabcentral/fileexchange/47081-flmm2>`__ (MATLAB)
* `differint <https://github.com/differint/differint>`__ (Python)
* `FractionalDiffEq.jl <https://github.com/SciFracX/FractionalDiffEq.jl>`__ (Julia)
* `FdeSolver.jl <https://github.com/JuliaTurkuDataScience/FdeSolver.jl>`__ (Julia)
appwindows 1.2.2
The appwindows library solves the problem of working with a graphical shell on different operating systems.
Requires Python: >=3.8

<img src="https://raw.githubusercontent.com/lexter0705/appwindows/refs/heads/master/appwindows.svg" alt="" width="40%" >

[![Py-Pi Downloads](https://img.shields.io/pypi/dm/appwindows.svg)](https://pypi.org/project/appwindows/) [![License - BSD 3-Clause](https://img.shields.io/pypi/l/appwindows.svg)](https://github.com/lexter0705/appwindows/blob/master/LICENSE.md)
<br>
[![unit_tests](https://github.com/lexter0705/appwindows/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/lexter0705/appwindows/actions/workflows/unit_tests.yml)

# Appwindows
The appwindows library solves the problem of working with a graphical shell on different operating systems.
# Install
```bash
pip install appwindows
```
# Docs
All documentation <a href="https://apparser.gitbook.io/appwindows">here</a> <br>
Link to <a href="https://pypi.org/project/appwindows/">PyPi</a>
# For Developers
1) If something doesn't work - open issue.
2) If you want something fixed - open issue.
3) If you can help with the library - email.

apparser.development@gmail.com

Any help in development is welcome)!
gen-art-framework 0.3.0
A framework for creating generative art with Python
Requires Python: <3.13,>=3.12
Keywords: art, creative-coding, generative-art, image-generation

# gen-art-framework

[![CI](https://github.com/josh-gree/gen-art-framework/actions/workflows/ci.yml/badge.svg)](https://github.com/josh-gree/gen-art-framework/actions/workflows/ci.yml)

A Python framework for generating art from parameterised scripts. Define parameter distributions in YAML, and the framework samples from them to create unique variations of your artwork.

## Installation

```bash
pip install gen-art-framework
```

Or with [uv](https://docs.astral.sh/uv/):

```bash
uv add gen-art-framework
```

## Quick Start

Create a script with a YAML parameter block in its docstring:

```python
"""
parameters:
  - name: seed
    distribution: constant
    value: 42
  - name: width
    distribution: constant
    value: 800
  - name: height
    distribution: constant
    value: 600
  - name: num_circles
    distribution: randint
    low: 20
    high: 50
  - name: colour
    distribution: choice
    values: ["#e94560", "#f39c12", "#00b894"]
"""

from PIL import Image, ImageDraw
import random

random.seed(seed)

img = Image.new("RGB", (width, height), "#1a1a2e")
draw = ImageDraw.Draw(img)

for _ in range(num_circles):
    x = random.randint(0, width)
    y = random.randint(0, height)
    r = random.randint(10, 50)
    draw.ellipse([x - r, y - r, x + r, y + r], fill=colour)

img
```

Generate images using the CLI:

```bash
# Generate a single image
gen-art sample my_script.py

# Generate 10 variations
gen-art sample my_script.py --count 10

# Specify output directory and seed for reproducibility
gen-art sample my_script.py -n 5 -o ./output -s 42
```

Output files are named `{script_name}_{index}_{seed}.png`.

## Contributing

### Development Workflow

1. Create a PR with your changes
2. CI will run tests, linting, and formatting checks
3. Once approved and merged to main, your changes are in the codebase
4. When ready to release, create and push a version tag:
   ```bash
   git tag v0.1.3        # Use semantic versioning: vMAJOR.MINOR.PATCH
   git push origin v0.1.3
   ```
5. The tag push automatically triggers a build and publishes to PyPI

**Version numbering:**
- `patch` (v0.1.1 → v0.1.2) for bug fixes
- `minor` (v0.1.1 → v0.2.0) for new features
- `major` (v0.1.1 → v1.0.0) for breaking changes

**CI checks:**
- Tests must pass
- No linting errors
- Code must be properly formatted

**Run checks locally:**
- `just test` - run tests
- `just lint` - check linting
- `just fmt` - format code
- `just check` - format and lint together

## Documentation

- [CLI Usage](docs/cli.md) - Command-line interface reference
- [Writing Scripts](docs/writing-scripts.md) - How to write parameterised art scripts
- [Distributions](docs/distributions.md) - Available parameter distributions
- [Python API](docs/api.md) - Programmatic usage
- [Examples](docs/examples.md) - Walkthrough of example scripts
mongobackup 0.3.0
A library to manage mongo backups and restoration from backup
Requires Python: >=3.6
Keywords: mongo, mongodb, database, backup

Mongo Backup
========
Mongo backup is designed to handle backing up and restoring a mongo database locally and on s3.

It can be installed by pip:

```
pip install mongobackup
```

Example usage follows.

```
# To do a local backup
from mongobackup import backup
backup("mongo_user", "mongo_password", "/var/backups/mongo/")

```
```
# To do a local backup of only one specific database, not every database on
# the server (some MongoDB auth/security configurations require this)
from mongobackup import backup
backup("mongo_user", "mongo_password", "/var/backups/mongo/",
       database="my_database_name")

```

```
# To do a local backup and a local backup on attached storage
from mongobackup import backup
backup("mongo_user", "mongo_password", "/var/backups/mongo/",
       attached_directory_path='/mnt/backups/')
```

```
# To do a local backup, backup on attached storage, and backup on S3
from mongobackup import backup
backup("mongo_user", "mongo_password", "/var/backups/mongo/",
       attached_directory_path='/mnt/backups/',
       s3_bucket="mongo-backup-bucket", s3_access_key_id="ASDF424242ASDF4242",
       s3_secret_key="lksLKDkakka983jk1DKJa3lkadkjq3askllkad")
```

```
# To do a local backup, backup on attached storage, and backup on S3,
# deleting all local and attached storage backups older than 30 days
from mongobackup import backup
backup("mongo_user", "mongo_password", "/var/backups/mongo/",
       attached_directory_path='/mnt/backups/',
       s3_bucket="mongo-backup-bucket", s3_access_key_id="ASDF424242ASDF4242",
       s3_secret_key="lksLKDkakka983jk1DKJa3lkadkjq3askllkad",
       purge_local=30, purge_attached=30)
```

```
# To download the latest S3 backup
from mongobackup import s3_download
s3_download("latest.tbz", s3_bucket="mongo-backup-bucket",
            s3_access_key_id="ASDF424242ASDF4242",
            s3_secret_key="lksLKDkakka983jk1DKJa3lkadkjq3askllkad")
```

```
# To see all s3 backups and download a particular one
from mongobackup import s3_list, s3_download
s3_list(s3_bucket="mongo-backup-bucket",
        s3_access_key_id="ASDF424242ASDF4242",
        s3_secret_key="lksLKDkakka983jk1DKJa3lkadkjq3askllkad")

s3_download("latest.tbz", s3_bucket="mongo-backup-bucket",
            s3_access_key_id="ASDF424242ASDF4242",
            s3_secret_key="lksLKDkakka983jk1DKJa3lkadkjq3askllkad",
            s3_file_key="backup_2015-03-05_21-40.tbz")
```

```
# To restore a backup
from mongobackup import restore
restore("mongo_user", "mongo_password", "latest.tbz")
```

```
# If you are having difficulties with restoring a backup from an older version
# of Mongo due to changes in their user permissions system, you can include the
# skip_system_and_user_files flag.
restore("mongo_user", "mongo_password", "latest.tbz", skip_system_and_user_files=True)
```
awscm-proxy 0.2.1
A cheap, secure, and straightforward serverless localhost proxy
Requires Python: >=3.12

awscm-proxy
============

.. image:: https://raw.githubusercontent.com/causematch/awscm-proxy/refs/heads/master/docs/images/logo.svg
   :alt: awscm-proxy logo
   :align: left

.. home-start

awscm-proxy (pronounced "awesome proxy") provides a quick, cheap, secure,
and straightforward serverless localhost proxy, useful for receiving
webhooks from third-party services on a local development server.  It is an
inexpensive alternative to services such as ngrok_ or localtunnel_.

We at CauseMatch_ integrate many external providers, including messaging
services, donor funds, and over a dozen payment processors.  Naturally, we
process a lot of webhooks.  Our engineers occasionally need to test those
webhooks on a local development server.  We don’t love exposing local ports
on the big bad internet and we’ve had enough of expensive commercial solutions
to a simple problem.  So we built a proxy using dirt-cheap, pay-as-you-go
AWS serverless building blocks.  And we cancelled our ngrok subscription.

Our solution seemed so obvious, we’re surprised we didn’t find any similar
utilities out there.  So we’re making ours available.  We hope others will
find it useful.  Drop us a line if you do!

Features
"""""""""

* unidirectional and bidirectional proxy configurations
* https endpoint
* localhost is not publicly exposed
* easily moved from one dev host to another
* incoming webhooks are queued and can be processed at a later time
* optional integration with mitmproxy and mitmweb UI

Non-goals
"""""""""""

* high performance
* support for protocols other than http
* support for streaming responses
* support for non-utf8 responses

Requirements
""""""""""""

* Python >= 3.12
* AWS credentials

Read more about |security|_.

Installation
"""""""""""""
::

    pip install awscm-proxy

Quickstart
"""""""""""
::

    awscm-proxy <local-endpoint>


.. _CauseMatch: https://www.causematch.com
.. _ngrok: https://ngrok.com/
.. _localtunnel: https://theboroer.github.io/localtunnel-www/
.. |security| replace:: security

.. home-end

.. _security: https://github.com/causematch/awscm-proxy/blob/master/docs/security.rst
fastmark 0.1.4
Run a subset of the pyperformance benchmarks quickly
Requires Python: >=3.11

This contains scripts to run a subset of the pyperformance benchmarks quickly.


### Usage

```
PYTHON_GIL=0 PYTHONHASHSEED=0 taskset -c 4 ./python fastmark.py
```

### Other recommendations

* Disable ALSR to reduce variation: `echo 0 | sudo tee /proc/sys/kernel/randomize_va_space`
* Use `perf stat -e instructions` to record instructions executed

### Setup

First build CPython locally. It doesn't need to be installed.

Install the dependencies. If Python is executed from the source directory, then this will install the packages in `~/.local/`.

```
./python -m ensurepip
./python -m pip install -r requirements.txt
```

### Gotchas

* Python compiles `.pyc` files for packages only when they are being installed. If the `PYC_MAGIC_NUMBER` changes, then Python will recompile the bytecode while the benchmark is running, potentially distorting results. It will not update the `.pyc` files for packages in `site-packages`, only local `__pycache__` directories.
* Fixing the `PYTHONHASHSEED` reduces variation but may be inapprorpriate for commits that substantially modify dictionary representation.

### Disabled benchmarks

* connected_components, shortest_path - networkx doesn't work with free threaded Python
* django_template, json, pycparser, pylint, thrift - Pyston benchmarks not yet enabled
* sphinx - benchmark messes with `__builtins__`
* python_startup - requires separate process
qmatchatea 1.5.6
Quantum matcha TEA python library for tensor network emulation of quantum circuits.
Requires Python: >=3.11

[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)

# Quantum Matcha Tea

Quantum Matcha Tea is a Tensor Network emulator for quantum circuits and linear optics circuits.
You can define your circuits either in [qiskit](https://github.com/Qiskit), or using Matcha's internal circuit interface `Qcircuit`.

If you use another quantum information library (such as [cirq](https://quantumai.google/cirq)) we suggest to save your circuit in `qasm`
format and then load it in qiskit.

The circuits ca be ran using the following backends:

- [numpy](https://numpy.org/), using the CPU in python;
- [cupy](https://cupy.dev/), using the GPU in python.

## Documentation

[Here](https://quantum_matcha_tea.baltig-pages.infn.it/py_api_quantum_matcha_tea) is the documentation.
The documentation can also be built locally with sphinx with the following python packages:

- `sphinx`
- `sphinx_rtd_theme`

and running the command `make html` in the `docs/` folder.

## Installation

Independent of the use-case, you have to install the dependencies. 
Installing the optional dependencies will enable the use of more 
tensor modules (for instance, supporting GPUs).

### Installation via pip

The package is available via PyPi and `pip install qmatchatea`.
After cloning the repository, a local installation via pip is
also possible via `pip install .`.

### Optional dependencies

The following optional dependencies are not installed by default.

- `cupy`: necessary to run on the GPU with the `tensor_module="numpy"`. The installation guide can be found
  at the [cupy website](https://docs.cupy.dev/en/stable/install.html).
- `torch`: necessary to run simulation with the `tensor_module="torch"`. The installation guide can be found
  at the [pytorch website](https://pytorch.org/get-started/locally/).
- `tensorflow`: necessary to run simulation with the `tensor_module="tensorflow"`. The installation guide can be found
  at the [tensorflow website](https://www.tensorflow.org/install).
- `jax`: necessary to run simulation with the `tensor_module="jax"`. The installation guide can be found
  at the [jax website](https://jax.readthedocs.io/en/latest/installation.html).

MPI simulations also require the package [`mpi4py`](https://mpi4py.readthedocs.io/en/stable/).

## Testing the package

To test the python package `qmatchatea` simply run from the command:
``
python3 -m unittest
``

## License

The project `qmatchatea` from the repository `py_api_quantum_matcha_tea`
is licensed under the following license:

[Apache License 2.0](LICENSE)

The license applies to the files of this project as indicated
in the header of each file, but not its dependencies.