semvec/pypi-packages huggingface dataset:
das 0.32.11
DAS
Requires Python: >=3.10

<!-- [![Test install](https://github.com/janclemenslab/das/actions/workflows/main.yml/badge.svg)](https://github.com/janclemenslab/das/actions/workflows/main.yml) -->

# Deep Audio Segmenter
_DAS_ is a method for automatically annotating song from raw audio recordings based on a deep neural network. _DAS_ can be used with a graphical user interface, from the terminal, or from within python scripts.

If you have questions, feedback, or find bugs please raise an [issue](https://github.com/janclemenslab/das/issues).

Please cite _DAS_ as:

Elsa Steinfath, Adrian Palacios, Julian Rottschäfer, Deniz Yuezak, Jan Clemens (2021).
_Fast and accurate annotation of acoustic signals with deep neural networks._
[eLife](https://doi.org/10.7554/eLife.68837)


See the documentation at [https://janclemenslab.org/das/](https://janclemenslab.org/das/) for instructions on how to [install DAS](https://janclemenslab.org/das/installation.html) and for a user guide:

- A [quick start tutorial](https://janclemenslab.org/das/quickstart.html) walks through all steps from manually annotating song, over training a network, to generating new annotations.
- How to use the [graphical user interface](https://janclemenslab.org/das/tutorials_gui/tutorials_gui.html).
- How to use _DAS_ [from the terminal or from python scripts](https://janclemenslab.org/das/tutorials/tutorials.html).



## Acknowledgements
The following packages were modified and integrated into das:

- Keras implementation of TCN models modified from [keras-tcn](https://github.com/philipperemy/keras-tcn) (in `das.tcn`)
- Trainable STFT layer implementation modified from [kapre](https://github.com/keunwoochoi/kapre) (in `das.kapre`)

See the sub-module directories for the original READMEs.
ebi-i2rf 0.0.4
Post processing package for the I2RF tutorial at EBI-TFS (Karlsruhe Institute of Technology)
Requires Python: >=3.8
Keywords: EBI-TFS, I2RF, i2rf, KIT-EBI

# I2RF Package for Data postprocessing

## How to install it:

```
python -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple ebi_i2rf
```

## How to use it

Import at in your document using 
```
import i2rf.wsr2 as pp
```

The following values can be obtained for TUT04 WSR2 by creating a pp object ``data = pp.i2rf()``

- ``data.getAll()`` returns five (5) numpy arrays for
    - mDot
    - All species concentrations for all mDot
    - All temperatures at for all mDot
    - All residence times for all mDot 
    - Species names as they are ordered in the respective numpy array

- ``data.getSpecies(specific:list=None)`` returns two numpy arrays for
    - mDot
    - Specific species concentrations (defined by list of strings)
        - If list is None (or has value None): returns all concentrations

- ``data.temperature()`` returns two numpy arrays for
    - mDot
    - Temperature for all mDot

- ``data.getResidenceTime()`` returns two numpy arrays for
    - mDot
    - Residence Time for all mDot
polars-xdt 0.17.1
eXtra stuff for Dates and Times in Polars
Requires Python: >=3.9

# polars-xdt

## eXtra stuff for DateTimes

<h1 align="center">
	<img
		width="400"
		alt="polars-xdt"
		src="https://github.com/MarcoGorelli/polars-xdt/assets/33491632/928c68c4-4e71-45a7-bc89-14922c7ce61b">
</h1>

[![PyPI version](https://badge.fury.io/py/polars-xdt.svg)](https://badge.fury.io/py/polars-xdt)
[![Read the docs!](https://img.shields.io/badge/Read%20the%20docs!-coolgreen?style=flat&link=https://marcogorelli.github.io/polars-xdt-docs/)](https://marcogorelli.github.io/polars-xdt-docs/)

eXtra stuff for DateTimes in [Polars](https://www.pola.rs/).

- ✅ blazingly fast, written in Rust
- ✅ convert to and from multiple time zones
- ✅ format datetime in different locales
- ✅ convert to Julian Dates
- ✅ ~time-based EWMA~ (upstreamed to Polars itself)
- ✅ ~custom business-day arithmetic~ (upstreamed to Polars itself)

Installation
------------

First, you need to [install Polars](https://pola-rs.github.io/polars/user-guide/installation/).

Then, you'll need to install `polars-xdt`:
```console
pip install polars-xdt
```

Read the [documentation](https://marcogorelli.github.io/polars-xdt-docs/) for a more examples and functionality.

Basic Example
-------------
Say we start with
```python
from datetime import datetime

import polars as pl
import polars_xdt as xdt

df = pl.DataFrame(
    {
        "local_dt": [
            datetime(2020, 10, 10, 1),
            datetime(2020, 10, 10, 2),
            datetime(2020, 10, 9, 20),
        ],
        "timezone": [
            "Europe/London",
            "Africa/Kigali",
            "America/New_York",
        ],
    }
)
```

Let's localize each datetime to the given timezone and convert to
UTC, all in one step:

```python
result = df.with_columns(
    xdt.from_local_datetime(
        "local_dt", pl.col("timezone"), "UTC"
    ).alias("date")
)
print(result)
```
```
shape: (3, 3)
┌─────────────────────┬──────────────────┬─────────────────────────┐
│ local_dt            ┆ timezone         ┆ date                    │
│ ---                 ┆ ---              ┆ ---                     │
│ datetime[μs]        ┆ str              ┆ datetime[μs, UTC]       │
╞═════════════════════╪══════════════════╪═════════════════════════╡
│ 2020-10-10 01:00:00 ┆ Europe/London    ┆ 2020-10-10 00:00:00 UTC │
│ 2020-10-10 02:00:00 ┆ Africa/Kigali    ┆ 2020-10-10 00:00:00 UTC │
│ 2020-10-09 20:00:00 ┆ America/New_York ┆ 2020-10-10 00:00:00 UTC │
└─────────────────────┴──────────────────┴─────────────────────────┘
```

Read the [documentation](https://marcogorelli.github.io/polars-xdt-docs/) for more examples!

Logo
----

Thanks to [Olha Urdeichuk](https://www.fiverr.com/olhaurdeichuk) for the illustration.
pypolyline 0.5.6
Fast Google Polyline encoding and decoding using Rust FFI
Requires Python: >=3.10
Keywords: Geo, Polyline

![example workflow](https://github.com/urschrei/pypolyline/actions/workflows/wheels.yml/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/urschrei/pypolyline/badge.svg?branch=master)](https://coveralls.io/github/urschrei/pypolyline?branch=master) [![Downloads](https://pepy.tech/badge/pypolyline)](https://pepy.tech/project/pypolyline)[![DOI](https://zenodo.org/badge/63355673.svg)](https://zenodo.org/badge/latestdoi/63355673)

# Fast Google [Polyline](https://developers.google.com/maps/documentation/utilities/polylinealgorithm) Encoding and Decoding

## Installation
`pip install pypolyline`  

### Supported Python Versions
All [_currently_ supported Python versions](https://devguide.python.org/versions/).

### Supported Platforms
- Linux (`manylinux*`-compatible, x86_64 and aarch64)
- macOS (x86_64 and arm64)
- Windows 64-bit

## Usage
Coordinates must be in (`Longitude, Latitude`) order

```python
from pypolyline.cutil import encode_coordinates, decode_polyline

coords = [
            [52.64125, 23.70162],
            [52.64938, 23.70154],
            [52.64957, 23.68546],
            [52.64122, 23.68549],
            [52.64125, 23.70162]
         ]

# precision is 5 for Google Polyline, 6 for OSRM / Valhalla
polyline = encode_coordinates(coords, 5)
# polyline is 'ynh`IcftoCyq@Ne@ncBds@EEycB'
decoded_coords = decode_polyline(polyline, 5)
```

## Error Handling
Failure to encode coordinates, or to decode a supplied Polyline, will raise a `RuntimeError` containing information about the invalid input.


## How it Works
FFI and a [Rust binary](https://github.com/urschrei/polyline-ffi)

## Is It Fast
…Yes.  
You can verify this by installing the `polyline` package, then running [`benchmarks.py`](benchmarks.py), a calibrated benchmark using `cProfile`.  
On an M2 MBP, The [pure-Python](https://pypi.org/project/polyline/) test runs in ~2500 ms, the [Flexpolyline](https://pypi.org/project/flexpolyline/) benchmark runs in ~1500 ms and The Rust + Cython benchmark runs in around 80 ms (30 x and 17.5 x faster, respectively).

## License
[The Blue Oak Model Licence 1.0.0](LICENCE.md)

## Citing `Pypolyline`
If Pypolyline has been significant in your research, and you would like to acknowledge the project in your academic publication, we suggest citing it as follows (example in APA style, 7th edition):

> Hügel, S. (2021). Pypolyline (Version X.Y.Z) [Computer software]. https://doi.org/10.5281/zenodo.5774925

In Bibtex format:


    @software{Hugel_Pypolyline_2021,
    author = {Hügel, Stephan},
    doi = {10.5281/zenodo.5774925},
    license = {MIT},
    month = {12},
    title = {{Pypolyline}},
    url = {https://github.com/urschrei/simplification},
    version = {X.Y.Z},
    year = {2021}
    }
emojit 1.1.0
Support for emoji digits in Python
Requires Python: <4.0,>=3.9

# Emojit

This package aims to address a long-standing Python issue:
```python
int("1️⃣") != 1
```

## Usage

```python
from emojit import emj

emoji_str = emj("4️⃣0️⃣2️⃣")

assert isinstance(emoji_str, str) is True
assert int(emoji_str) == 402
```
<sub><sup>Please, don't actually use this.</sup></sub>

## Simplified usage

You can simplify the previous example as:
```python
# coding: emoji-digit

emoji_str = "4️⃣0️⃣2️⃣"

assert isinstance(emoji_str, str) is True
assert int(emoji_str) == 402
```

To achieve this, you have to do two things. Find your `site-packages` directory:
```shell
python -c "import site; print(site.getsitepackages())"
```

And then create a new file called `sitecustomize.py` in this directory with the following contents:
```python
import builtins
import codecs

import emojit
import emojit.emoji_digit_codec

builtins.emj = emojit.emj

codecs.register(emojit.emoji_digit_codec.search_function)
```

You can read more about codecs [here](https://docs.python.org/3/library/codecs.html).

## Advanced usage

### Underscores as visual separators

```python
from emojit import emj

assert int(emj("4️⃣0️⃣2️⃣_0️⃣0️⃣0️⃣")) == 402_000
```

### Shorthand emojis

```python
from emojit import emj

assert int(emj("🔟")) == int(emj("1️⃣0️⃣"))
assert int(emj("💯")) == int(emj("1️⃣0️⃣0️⃣"))
assert int(emj("🔢")) == int(emj("1️⃣2️⃣3️⃣4️⃣"))
```

## Support

This package is considered feature complete. It will be archived once the functionality is upstreamed into the Python standard library.
edwh-git-plugin 0.1.0
git gud
Requires Python: >=3.11
Keywords: edwh

# edwh-demo-plugin

[![PyPI - Version](https://img.shields.io/pypi/v/edwh-demo-plugin.svg)](https://pypi.org/project/edwh-demo-plugin)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/edwh-demo-plugin.svg)](https://pypi.org/project/edwh-demo-plugin)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## USING THIS TEMPLATE REPOSITORY
1. remove this markdown section;
2. replace 'demo' in README.md, pyproject.toml and the name of the plugin in `src` to your actual plugin name;
3. (add your actual plugin code of course);
4. run `semantic-release publish`, `hatch build -c` and `hatch publish`.

## Installation

```console
pip install edwh-demo-plugin
```

But probably you want to install the whole edwh package:

```console
pipx install edwh[demo]
# or
pipx install edwh[plugins,omgeving]
```

## License

`edwh-demo-plugin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.