semvec/pypi-packages huggingface dataset:
ternviz 0.6.3
Render SMILES into 3D video
License: MIT

# Tern Viz
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/whitead/ternviz/blob/main/colab/ternviz.ipynb)

Convert SMILES to a 3D rotating video. Check-out the Twitter bot [@ternviz](https://twitter.com/ternviz)!

## Install

You need to install both [VMD](https://www.ks.uiuc.edu/Research/vmd/) and ffmpeg. After that:

```py
pip install ternviz
```

## Usage

It can be used to render stills, rotating videos, comparisons of molecules, and compilation videos of multiple proteins.

### Render a molecule

To render a molecule:

```sh
ternviz CCCO
```

You may need to specify the path to VMD or ffmpeg:

```sh
ternviz CO --vmd /path/to/vmd/executable
```

You can modify a few things too:

```sh
ternviz CCCO --name "my molecule" --color white
```

try `--low-quality` to render quickly.

### Render a protein

This will do a still frame
```sh
ternviz-pdb 1A1L
```

To do a rotating movie, specify number of frames (at 60 fps)

```sh
ternviz-pdb 1A1L --frames 60
```

You can pass in multiple PDBs

```sh
ternviz-pdb my.pdb other.pdb
```

You can specify how the structure is colored and other details

```sh
ternviz-pdb 1A1L --frames 60 --color white --scolor Chain
```

### Aligning PDBs

You can align structures before rendering

```sh
ternviz-align ref.pdb *.pdb
```

by default it aligns on the protein. You can also change selection string, using [MDAnalysis Selection String Syntax](https://docs.mdanalysis.org/stable/documentation_pages/selections.html)

```sh
ternviz-align ref.pdb --sel "chainid B" *.pdb
```
## Example Render

https://user-images.githubusercontent.com/908389/147892964-c15ac0fd-44be-4473-b82a-799260e0f373.mp4
robotsparse 1.0
A python package that enhances speed and simplicity of parsing robots files.
License: MIT
Keywords: parsing, parser, robots, web-crawling, crawlers, crawling, sitemaps, sitemap

# robotsparse
![Pepy Total Downlods](https://img.shields.io/pepy/dt/robotsparse)<br>
A python package that enhances speed and simplicity of parsing robots files.

## Usage
Basic usage, such as getting robots contents:
```python
import robotsparse

#NOTE: The `find_url` parameter will redirect the url to the default robots location.
robots = robotsparse.getRobots("https://github.com/", find_url=True)
print(list(robots)) # output: ['user-agents']
```
The `user-agents` key will contain each user-agent found in the robots file contents along with information associated with them.<br>

Alternatively, we can assign the robots contents as an object, which allows faster accessability:
```python
import robotsparse

# This function returns a class.
robots = robotsparse.getRobotsObject("https://duckduckgo.com/", find_url=True)
assert isinstance(robots, object)
print(robots.allow) # Prints allowed locations
print(robots.disallow) # Prints disallowed locations
print(robots.crawl_delay) # Prints found crawl-delays
print(robots.robots) # This output is equivalent to the above example
```

### Additional Features
When parsing robots files, it sometimes may be useful to parse sitemap files:
```python
import robotsparse
sitemap = robotsparse.getSitemap("https://pypi.org/", find_url=True)
```
The above code contains a variable named `sitemap` which contains information that looks like this:
```python
[{"url": "", "lastModified": ""}]
```
enpass 0.1.2
Simple entropy password validator.
License: MIT
Keywords: entropy password validator strength

![Enpass](https://raw.githubusercontent.com/Aresshu/enpass/main/data/logo.png "Enpass")

### Enpass is a simple password entropy strength validator
This project can be used to validate a password strength. Designed to be lightweight with the following benefits:
* No external API calls
* No large data sets
* Focused entirely on raw entropy values
* More flexible (doesn't require uppercase, numbers, special characters)


## Installation
```bash
pip install enpass
```
## Quick Start
`calc_entropy` calculates the entropy of a password in bits.
    
Entropy equation = log2(B^L) 
`B = Base; L = Length`
```python
    import enpass as ep

    password = 'P@SSW0RD!'

    #Calculates the entropy of a password in bits.
    entropy = ep.calc_entopy(password)
```
`validate` checks if the password's entropy meets the specified minimum requirement.

Passwords should ideally be > 60.
Great Passwords should be between 70-90.
```python
    min_entropy = 60.0
    # Checks if the password's entropy meets the specified minimum requirement.
    validate = ep.validate(entropy, min_entropy)
```
`estimate_bruteforce_time` assumes that cracking time scales linearly with the number of possible combinations.

While this might hold for straightforward brute-force attacks, more sophisticated attacks,
such as dictionary attacks or those exploiting weaknesses in password hashing algorithms, may have different time complexities.
```python
    guesses_per_second = 100_000_000
    # Estimates the amount of time required to brute-force a password 
    time_brute_estimate = ep.estimate_bruteforce_time(entropy, guesses_per_second)
```
## Roadmap
- [x] Entropy Calculator
- [x] Brute-Force Estimate
- [ ] Scoring
- [ ] Feedback
- [ ] Throttling/Hashing Brute-Force Estimate
- [ ] Character Sequences

## Contributing
Contributions are welcome!