semvec/pypi-packages huggingface dataset:
f-pass-gen 1.0.0
Strong Passwords Generator made with python

# f-pass-gen

<b>Strong password generator with python</b>

## How to use

`from pass_gen import FPassGen`\
`pass_gen = FPassGen(text=None, key=None)`\
`pass_gen.generate_password(text=None, key=None)`\
`password = pass_gen.code`\
or\
`import pass_gen`\
`pass_gen = pass_gen.FPassGen(text=None, key=None)`\
`pass_gen.generate_password(text=None, key=None)`\
`password = pass_gen.code`

## Make it run from terminal

- first you need to install python in your machine
- install pyinstaller with `pip install pyinstaller`
- run `pyinstaller pass-gen --one-file`
- if you in linux copy the dist/pass-gen to /bin or /home/username/bin
- if on windows just add it to the PATH

Now you can just open terminal/command-prompt and type pass-gen

## More about the module

### On python script

generate_password method can accept to optional arguments\
`generate_password(text=None, key=None)`\
text: is the text to be ciphered\
key: is the key to be used in the generation
key optional in the constructor and the method, but the text must be set in one of them

examples:\

- `pass_gen = FPassGen("demo text") pass_gen.generate_password() password = pass_gen.code`\
- `pass_gen = FPassGen() pass_gen.generate_password("demo text", "demo key") password = pass_gen.code`
- `pass_gen = FPassGen() pass_gen.generate_password("demo text") password = pass_gen.code`
- `pass_gen = FPassGen("demo code", "demo key") pass_gen.generate_password() password = pass_gen.code`

`pass_gen.code` is the result of the encryption

if the `key` is not set, the class will randomly generate one

### Command Line Usage

the same if you launch it from terminal
examples:

- `$ pass-gen`
- `$ pass-gen "demo text"`
- `$ pass-gen "demo text" "demo key"`

results:

- in case one: the terminal will prompt to ask you for the text and generate a random key
- in case tow: the terminal will take the entered text and encrypt it with a random generated key
- in case three: the terminal will take the entered text and encrypt it with the given key

we will add more functionality in the future
Venue-Mapper 1.0.2
Maps BibTex venue/journal/booktitle strings to their acronyms.
Requires Python: >=3.5

# Venue mappings
![Venue Mapper](https://github.com/atlarge-research/venue_mappings/workflows/Venue%20Mapper/badge.svg)

Venue mappings is a library project developed by [Laurens Versluis](https://github.com/lfdversluis/) to map venue BibTex strings found in sources such as [DBLP](dblp.uni-trier.de/) and [Google Scholar](scholar.google.com/) to the acronym of the venue.

For example the strings `FGCS`, `Future Generation Comp. Syst.` and `Future Generation Computer Systems` can be found in BibTex entries and other corpuses. The venue mapper maps these strings to their corresponding acronym -  `FGCS`.
Article meta-data stored in, e.g., a database then becomes easier to query, as well as sanitizing and making uniform your BibTex entries.  

## Usage
```
from venue_mapper.venue_mapper import VenueMapper
venue_mapper = VenueMapper()
acronym = venue_mapper.get_abbreviation("FGCS")
```

## Scope
Currently, this repository contains venues from the systems community.
Naturally, we encourage additions through pull-requests.

## Version structure
Currently, the version is in the form of `x.y.z`.
- If any update is not backwards compatible and users need to modify code to make the upgrade work, `x` will be upped. `y` and `z` will be reset, e.g., `1.2.3` -> `2.0.0`
- If one or more new venues are added, `y` will be upped. `x` will not change and `z` will be reset, e.g., `1.2.3` -> `1.3.0`.
- If an update only applies fixes because some BibTex strings were missed, `z` will be upped. `x` and `y` will not change, e.g., `1.2.3` -> `1.2.4`.

Please note that any of `x`, `y`, and `z` can go beyond 9, i.e., `1.10.1610` is a perfectly fine version.

## Project Structure
The file `venue_mapper.py` contains the `VenueMapper` class.
This class contains the `venues` dictionary which contains the matching rules.

There are currently five matching types: `EXACT`, `STARTS_WITH`, `ENDS_WITH`, `CONTAINS`, `REGEX`

All tests are located in the `tests` folder. Each test is named `test_<acronym of venue>.py` for clarity.
We use the `BaseRunner` class to make each test as simple as possible. We believe each test is self-explanatory.

## What's up with these five matching types?
Initially, this project used regex rules for all matches, including exact matches.
After some micro benchmarks, we found that moving to this type of matching, and caching already seen strings led to a 6-8x speedup depending on the computer.