semvec/pypi-packages huggingface dataset:
passgr 0.0.1
A simple password generator
Requires Python: >=3.8

# passgr

Description. 
The package passgr is used to:
	- generate passwords

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install passgr

```bash
pip install passgr
```

## Usage

```python
from passgr import pass_generator
pass_generator.my_function()
```

## Author
Davi H.

## License
[MIT](https://choosealicense.com/licenses/mit/)
lfnt 0.1.11
For eating development-environment elephants.
Requires Python: >=3.9,<4.0

[![PyPI version](https://badge.fury.io/py/lfnt.svg)](https://badge.fury.io/py/lfnt)

# Elephant (lfnt)

`lfnt` eats development environments.

## What??

Setting up a development environment is a lot like eating an elephant—you have to take it one bite at a time.
Whether you're such a noob that you don't even know what a noob is or you're such a vet that you already have opinions about this project, you know that starting from scratch is daunting.
Meanwhile, we all keep eating, and re-eating, the same elephant!

In my humble opinion, that's just stupid.

But I'm not alone.
Developers are now commonly adding their config files and installation scripts to their own code repos.
Yet even that is still a pain in the ass to manage, especially when it comes down to every little detail.

That's where `lfnt` comes in useful—it handles all of the grunt-work for you.
`lfnt` eases the pain of managing your development environment by:

* Maintaining your configuration repository
* Keeping track of what packages have been installed and how
* Restoring your whole setup to a new machine from your configuration repository
* Providing a platform for environment sharing and test-driving others'

So just install this package and let `lfnt` do the rest!

## How??

`lfnt` is written in Python3, which means that most workstations are already equipped to use it.
It allows you to interact with your environment from a command-line and/or visually from a local web app.
You can use it to create a new configuration repository or sync with an existing one—and even perform automatic backups.

All you need to do is start up a terminal and run:

`pip install lfnt`

After the installation is complete, run `lfnt` with no arguments for a synopsis.
For example:

```
$ lfnt
Usage: lfnt [OPTIONS] COMMAND [ARGS]...

  For eating development-environment elephants.

Options:
  --help  Show this message and exit.

Commands:
  browse    Run in a web browser.
  dump      Take a config dump.
  eat       Ingest packages and applications.
  init      Initialize a configuration.
  poop      Eliminate packages and applications.
  remember  Save and commit environment.
```
fastgrouper 0.1.2
A package for applying efficient groupby operations.
Requires Python: >=3.6
Keywords: fastgrouper,grouping,groupby,fast

[![<sjoshistrats>](https://circleci.com/gh/sjoshistrats/fastgrouper.svg?style=shield)](https://app.circleci.com/pipelines/github/sjoshistrats/fastgrouper?branch=master)

# fastgrouper
Allows for fast groupby-apply operations, in python.
  
# Install
  
Users can install the package from PyPI via:
  
```shell
python -m pip install fastgrouper
```

# Usage

Use the `arr` interface, for numpy array focused applications.

```python
import numpy as np
import fastgrouper.arr
  
def baz(x, y):
    return np.mean(x + y) - 3

# Sample arrays, to slice
xvals = np.array([1, 2, 10])
yvals = np.array([4, 5, 6])
  
# Group ids
gids  = np.array([1, -3, 1])

# Perform groupby-apply; note that keyword args are supported as well.
grpd = fastgrouper.arr.Grouped(gids)
result = grpd.apply(baz, xvals, y=yvals) # np.array([7.5, 4])

# The gids correponding to the result above can be found via the `dedup_gids` attribute.
grpd.dedup_gids # np.array([ 1, -3])

# Users can also perform groupby-apply, and then expand results back to align with the original gids.
result = grpd.apply_expand(baz, xvals, yvals) # np.array([7.5, 4, 7.5])
```

The `li` interface returns the results over the groups as a list (instead of an array); this may be useful for functions that return different-sized results. Note that in all interfaces (e.g. both `arr` and `li`), the order in which the group elements appear is preserved when the group slices are passed to the function being applied.

  
```python
import numpy as np
import fastgrouper.li
  
def bop(x):
    return list(x)

# Sample arrays, to slice
xvals = np.array([2, 3, 4])
  
# Group ids
gids  = np.array([10, -20, 10])

grpd = fastgrouper.li.Grouped(gids)
grpd.apply(bop, xvals) # [[2, 4], [3]]
```
  
For additional examples, checkout the [tests](./python/fastgrouper/test).