semvec/pypi-packages huggingface dataset:
password-suggestion 0.0.7
A powerful but simple to use strong password generation library
Requires Python: >=3.7

##### A strong but super simple to use library to generate passwords 
 * Supports Django 
 * Generate a simple password of default length 6-16.

## Usage
 * Install the library.
 * Import the library.
 * Modify the default properties. (Optional)
 * Generate strong password (Default length of password 6-16 unless specified via properties).

``` bash
  pip install password_suggestion
```

``` python
  from easy_password_generator import PassGen

  pwo = PassGen()
  pwo.generate()
```


## Configuration

| property   |                          Description                 | Default |
| ---------- |------------------------------------------------------| ------- |
| minlen     |   Minimum length of the password                     | 6 |
| maxlen     |   Maximum length of the password                     | 16 |
| minuc  |   Minimum upper case characters  | 1 |
| minlc  |   Minimum lower case characters  | 1 |
| minnum |   Minimum numerical characters | 1 |
| minsc  |   Minimum special characters| 1 |

## Examples:
``` python
  pwo = PassGen()
  pwo.generate()
```

### Generate a custom password
``` python
  pwo = PassGen(minlen = 10, maxlen=15)

  pwo.generate()
```

### Generate Non Duplicate Password
``` python
  pwo = PassGen()

  # length of required password
  pwo.next(20)
```
## Update V0.0.7
Introduces next function

## Update V0.0.6
From version 0.0.6, Initial library launch

## Contributions
Contributions can be made with PR or contact prathista1995@gmail.com 

## License
 * [MIT](LICENSE)
NetworkSim-brysonreese 0.0.3
A Network Simulator that randomly generates and calculates minimum paths in a configurable random doubly-weighted graph
Requires Python: >=3.9

﻿## NetworkSim
NetworkSim is a project I wrote for CPE 400 (Computer Networking) and have implemented testing and CI/CD for as a part of CS 491 (DevOps and Testing).

NetworkSim generates random double-weighted graphs and finds the shortest distance between each node to every other node in the graph. The user can specify the number of simulations they want to run and the program will create a directory of directories representing each simulation. In each simulation directory exists a .png picture of the graph and a text file that has a list of the shortest path between every node to every other node, along with the weight of taking that path.

This program simply brute forces all of these calculations, so I would recommend playing with it a bit before going and running a million simulations on a Core 2 Duo. YMMV!
___
I would recommend using a virtual environment to run this package.

To initialize, simply run:

    python3 -m venv env
    
    source env/bin/activate
Then to install the required packages, simply run:

    pip install -r requirements.txt
Once all required libraries are installed, simply run:

    python src/networksim_package/NetworkSim.py

Or change directory into the packag directory by running:

    cd src/networksim_package/
    python NetworkSim.py
___
After reading all of the initial prompts, please input the parameters that one would like to use to run the simulations. Some lightweight parameters that one can use to test the functionality can be found below:

Number of simulations: __ (Up to the user)

Estimated number of nodes: 15 (Takes usually less than 3 seconds per sim on 2017 Macbook Pro i7)

Edge creation probability: 0.2 (0.3 can be fine too, but expect longer time per simulation iteration)

Min/max weights for nodes/edges: __ (Up to the user, just arithmetic, doesn't affect performance)
apav 1.2.2
A Python library for Atom Probe Tomography analysis
Requires Python: >=3.6
Keywords: atom probe,tomography,field evaporation,data analysis,materials science

# APAV: Python analysis for atom probe tomography
[![Documentation Status](https://readthedocs.org/projects/apav/badge/?version=latest)](https://apav.readthedocs.io/en/latest/?badge=latest)
[![coverage report](https://gitlab.com/jesseds/apav/badges/master/coverage.svg)](https://gitlab.com/jesseds/apav/commits/master)
[![pipeline status](https://gitlab.com/jesseds/apav/badges/master/pipeline.svg)](https://gitlab.com/jesseds/apav/-/commits/master)

APAV (Atom Probe Analysis and Visualization) is a Python library for the analysis and
visualization of atom probe tomography experiments, for example:

* Disambiguation of multiple detector events in mass or time-of-flight histograms
* Correlation histograms and molecular dissociation
* Calculation of molecular isotopic distributions
* Read/write common file formats (*.pos, *.epos, *.ato, *.apt, and *.rrng) or simulated data
* Roi primitives for localized analysis
* Interactive visualizations
* Build analyses in the compositional domain (i.e. compositional "grids" with 1st + 2nd pass delocalization)
* Quantify mass spectra using various levels of fitting/background correction

APAV is open source (GPLv2_ or greater) and is platform independent. It is written in Python 3
using NumPy to accelerate mathematical computations, and other mathematical tools for more niche calculations.
Visualizations leverage pyqtgraph and other custom Qt widgets.

# Support
Post discussion to the [GitLab issue tracker](https://gitlab.com/jesseds/apav/-/issues)

# Documentation
Documentation is found at: https://apav.readthedocs.io/

# FAQ
**Why use this over IVAS or program X?**

APAV was never intended to be used as an IVAS substitute or replacement. While much of the 
functionality may overlap, APAV fills feature gaps in IVAS deemed lacking (or otherwise non-existent).
Specifically:
1. Multiple-event analysis (correlation histograms, multiple event histograms, multiple event mass quantifications.
2. Explicit control over mass spectrum analysis (background models, fitting, binning).
3. Provide an interface for the development of custom analyses--a common need in the academic community.

**Why is there no GUI for APAV?**

APAV is a python *library*, there is no plan for a graphical user interface for APAV. It does, however, include
some custom interactive GUI visualizations using pyqtgraph and Qt.
conformal-predictors-patpizio 0.2.2
Conformal Prediction in many flavours
Requires Python: >=3.6

# conformal_predictors
 
Work in progress.

Install with
```
pip install --index-url https://test.pypi.org/simple/ --no-deps conformal_predictors-patpizio
```
The Conformal Prediction framework is described in a book by [Vovk et al. (2005)](http://alrw.net). 

[A Tutorial on Conformal Prediction](https://jmlr.org/papers/volume9/shafer08a/shafer08a.pdf) provides a gentle introduction.
hunter-tdb 1.3
A virtual ant farm of sorts
Requires Python: >=3.8

# Hunter
## Summary
This is a simple project to explore the idea of simulating a hunter trying to survive in his/her environment, and the development of all the systems necessary to accomplish that.

Currently, the gameplay is represented by ASCII characters rendered in a small console window. There is an H, the Hunter, that moves around and attempts to survive. The Hunter's vital stats are displayed on the left and the Hunter's action log is displayed at the bottom. When hungry, the Hunter will search for berries to eat or rabbits to hunt (the R's), and when tired, the Hunter will return to camp (C) to sleep.

There are two player controls right now:
- **F** - toggle fog of war
- **H** - toggle user interface

And that's it! This is not a game for playing so much as observing (like an ant farm). From this humble start, I hope to build a rich world that is genuinely enjoyable to observe. And eventually I do plan to add more ways for the player to interact with the world. But for now, you'll have to use your imagination. :)

If you really want to tinker, you can modify the stats in [this file](https://github.com/trevordbabcock/hunter/blob/master/hunter_pkg/config/stats.json). For example, in the "rabbit" section try changing "spawn" to 0.2 and see what happens. User beware: there are tons of ways to break the game messing with this file! 

<br/>
<img src="blog/img/dead-rabbit.png" alt="drawing" width="800"/>
<br/><br/>

For more info, see blog entries in the [blog directory](https://github.com/trevordbabcock/hunter.git). There, you can read about my progress, process, goals for the future, and general ruminations. [This post](https://github.com/trevordbabcock/hunter/blob/master/blog/2020.09.26.CREATURES.ECOSYSTEMS.md), where I organized my thoughts on how to simulate creatures of varying complexity, may be a particularly interesting starting point.

## Installation
### Using Python Eggs
Install pyenv. For MacOSX, run the following:
```
> brew install pyenv
```
Note: some other setup steps may be necessary.


Using pyenv, install Python 3.8 or higher:
```
> pyenv install 3.8.0
```

Install the Hunter egg:
```
> pip install hunter-tdb==0.8.0
```

Run the game!
```
> run hunter
```

### Running from source
Install python 3.8 or higher:
```
However you like. :)
```

Clone source:
```
git clone https://github.com/trevordbabcock/hunter.git
```

Install requirements:
```
cd hunter
pip install -r requirements.txt
```

Run the game:
```
./hunter_pkg/main.py
```

Have fun! Any feedback is welcome. :)