semvec/pypi-packages huggingface dataset:
aaa-approx 1.0.2
A Python implementation of the AAA algorithm for rational approximation

# The AAA algorithm for rational approximation [![Build Status](https://travis-ci.com/c-f-h/aaa.svg?branch=master)](https://travis-ci.com/c-f-h/aaa)

This is a Python implementation of the AAA algorithm for rational approximation
described in the paper "The AAA Algorithm for Rational Approximation" by Yuji
Nakatsukasa, Olivier Sète, and Lloyd N. Trefethen, SIAM Journal on Scientific
Computing 2018 40:3, A1494-A1522.
[(doi)](https://doi.org/10.1137/16M1106122)

A MATLAB implementation of this algorithm is contained in [Chebfun](http://www.chebfun.org/).
The present Python version is a more or less direct port of the MATLAB version.

The "cleanup" feature for spurious poles and zeros is not currently implemented.

## Installation

The implementation is in pure Python and requires only numpy and scipy as
dependencies. Install it using pip:

    pip install aaa-approx

## Usage

Here's an example of how to approximate a function in the interval [0,1]:

    import numpy as np
    from aaa import aaa

    Z = np.linspace(0.0, 1.0, 1000)
    F = np.exp(Z) * np.sin(2*np.pi*Z)

    r = aaa(F, Z, mmax=10)

Instead of the maximum number of terms `mmax`, it's also possible to specify
the error tolerance `tol`.  Both arguments work exactly as in the MATLAB
version.

The returned object `r` is an instance of the class `aaa.BarycentricRational` and can
be called like a function. For instance, you can compute the error on `Z` like this:

    err = F - r(Z)
    print(np.linalg.norm(err, np.inf))

If you are interested in the poles and residues of the computed rational function,
you can query them like

    pol,res = r.polres()

and the zeroes using

    zer = r.zeros()

Finally, the nodes, values and weights used for interpolation (called `zj`, `fj`
and `wj` in the original implementation) can be accessed as properties:

    r.nodes
    r.values
    r.weights
flickr-recovery 0.0.1
Python tool to unpack, reorder into albums and rename photos to original names after pooling flick dump

# flickr-recovery
Simple python tool to reorder photos into albums &amp; rename them to previous names after pooling flick dump

If for some reason you had to pull dump from flickr, you may find it pretty much useless
(several thousands of photos, just put with incorrect names into zip files +-4 Gb each)
So, this tool is intended to help you resorting albums structure according to
metadata from flickr itself


First of all, you can just find a guy who know python, and ask him to read this manual and perform required steps on your Mac / PC / etc.

If this one is not good enough, or something, you need to do two things: extract data, and reorder it. Both can be done with the flickr-recovery;
installation requires python3.5+ and pip (I'll recommend creating new virtualenv for it)
In this virtualenv (or just in base environment) run:
```shell
python -m pip install flickr-recovery
python -m flickr-recovery extract-to-albums /path/to/your/archives/all/in/one/dir
```

Make sure you have enough space on the partition with archives;
Or, if you want to extract images to different location, add images_dir to command call

```shell
python -m flickr-recovery extract-to-albums /path/to/your/archives/all/in/one/dir /path/to/images/
```

The directory should exists, if specified. Otherwise, it would be /path/to/your/archives/all/in/one/dir/images for images
and /path/to/your/archives/all/in/one/dir/data for account data