semvec/pypi-packages huggingface dataset:
forwarderd 13
SSH Forward Daemon
Requires Python: >=3.7

SSH port forwarder daemon

### Daemon
Install `forwarderd[daemon]` and run `forwarderd.__main__` any suitable way

Example for Linux, will create systemd service "forwarderd":
```bash
mkdir forwarderd
cd forwarderd
python3 -m venv .  # python version should be 3.7 or higher
source bin/activate
python3 -m pip install pip --upgrade
python3 -m pip install pip forwarderd[daemon]
python3 -m forwarderd --systemd-install
systemctl start forwarderd
```

### Usage
Install `forwarderd`, then request tunnel spawn such way
```python
from forwarderd import spawn_tunnel, SpawnTunnelRequest

spawn_resp = await spawn_tunnel(
    SpawnTunnelRequest(
        ssh_addr='hostname:port',  # port is optional, 22 by default
        ssh_user='user',
        ssh_identity_file='/root/.ssh/forward_key',  # must be accessible for daemon
        remote_addr='localhost:80',
    )
)
spawn_resp.host  # local bind host
spawn_resp.port  # local bind port
```

If `local_addr` not specified, host is __localhost__ and
paramiko will decide which port to use

There is also [Go client](https://github.com/elchinchel/gorwarderd)
scikit-prune 0.1.0
Prune your sklearn models.

# scikit-prune

> Prune your sklearn models.

Deep learning libraries offer pruning techniques to ensure that the
models are lightweight when they are stored on disk. It's a technique
that makes a lot of sense; you often don't need float64 numbers to
represent the weights of a machine learning model. 

It got me thinking, would such a technique also work in scikit-learn? 

## Enter `scikit-prune`

As a demo, let's say that we're dealing with a text classification use-case. 

```python
from sklearn.datasets import fetch_20newsgroups

text = fetch_20newsgroups()['data']
```

Then we might have a pipeline that fetches the sparse tf/idf features from
this text and then turns these into a dense representation via SVD. 

```python
from sklearn.pipeline import make_pipeline
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer

pipe = make_pipeline(TfidfVectorizer(), TruncatedSVD(300))
pipe.fit(text)
```

Then we can choose to save this pipeline on disk, preferably via
a system like [skops](https://github.com/skops-dev/skops).

```python
from skops.io import dump

dump(pipe, "piper-orig.skops")
```

This results in a 275Mb file on disk, which is actually kind of big, and
the most significant chunk of these megabytes are spent on the float64 numpy 
arrays that belong to the SVD object. 

With this library, you can shrink that down a bit. 

```python
from skprune import prune 

dump(prune(pipe), "piper-lite.skops")
```

Now, the file is fair bit lighter, only 126Mb on disk. Which is a step
in the right direction. You can get it down even further by saving it 
as a ZIP file which moves it closer to 41Mb. 

## Caveats 

This technique can save a bunch of disk space for sure, but at least theoretically,
it can _also_ lead to some numerical mishaps when you try to apply the pruned pipeline. 
Always make sure that you check and evaluate the pruned pipeline before doing anything
in production with it! 

It's also good to remember that your results may certainly vary. In our example
the `TruncatedSVD` component was the culprit because it was dealing with a _very_ large internal
matrix. If your pipeline doesn't have very large matrices, you probably won't get
big savings in disk space.
swin 0.0.5
Swin: SoftWare INsights
Requires Python: >=3.11

# swin (SoftWare INsights)

Simple analytics for PyPI packages based on `pypistats` (https://pypi.org/project/pypistats). In addition to daily downloads chart, `swin` adds a linear trend line and a summary stats table.

## Installation from PyPI

`pip install --upgrade swin`

## Command-Line Use

    swin [--help] [--version] [--ref REF] package [package ...]

    positional arguments:
      package     PyPI package names for processing

    options:
      -h, --help  show this help message and exit
      --version   show program's version number and exit
      --ref REF   reference comparison package

`swin` will create 'charts' folder (or use the existing one) in the current directory and put there one PNG file per input package with daily downloads chart and a trend over time.

`swin` will also print a sorted table with download statistics of the packages specified in the command line.

If `REF` package is specified then `swin` creates additional charts for the share of input packages in comparison with the reference comparison package (e.g. `modin` downloads as percentage of `pandas` downloads over time). These charts include a trendline as well and prefixed with `share-`.
sentinel1-reader 0.1.5
A Sentinel-1 reader for ISCE3
Requires Python: >=3.9

## s1-reader

A package to read Sentinel-1 data into the ISCE3-compatible burst class.

### Features

+ Create ISCE3-compatible Sentinel1 burst class given:

  - S1 SAFE
  - subswath index
  - polarization
  - path to orbit directory

+ Monotonically increasing bursts IDs.

🚨 This toolbox is still in **pre-alpha** stage and undergoing **rapid development**. 🚨 

### Install

1. Download source code:

```bash
git clone https://github.com/opera-adt/s1-reader.git
```

2. Install dependencies:

```bash
conda install -c conda-forge --file s1-reader/requirements.txt
```

3. Install `s1-reader` via pip:

```bash
# run "pip install -e" to install in development mode
python -m pip install ./s1-reader
```

### Usage

The following sample code demonstrates how to process a single burst from a S1 SAFE zip:

```python
import s1reader

zip_path = "S1A_IW_SLC__1SDV_20190909T134419_20190909T134446_028945_03483B_B9E1.zip"
swath_num = 2
pol = "VV"

# read orbits
orbit_dir = '/home/user/data/sentinel1_orbits'
orbit_path = s1reader.get_orbit_file_from_dir(zip_path, orbit_dir, auto_download=True)

# returns the list of the bursts
bursts = s1reader.load_bursts(zip_path, orbit_path, swath_num, pol)
burst_ids = [x.burst_id for x in bursts]
```

### License

**Copyright (c) 2021** California Institute of Technology (“Caltech”). U.S. Government sponsorship acknowledged.

All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Caltech nor its operating division, the Jet Propulsion Laboratory, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.