semvec/pypi-packages huggingface dataset:
link-crab-TEST-KLUCSIK 0.2.2
A link crawler and permission testing tool for websites
Requires Python: >=3.6

# The Link Crab

A simple CLI tool which can crawl through your website and catch broken links, and can check user permissions to specific pages on your website.

## Workmode: Link gathering:
In this mode, you provide a starting url, and the Link Crab will crawl through the starting page, and all the page which is accessible thorugh links from that page and is in the same domain as the starting apge.
The program export the gathered links in a txt file, then exercise them, gathering response time and status code, and exporting these in a csv file.

## Workmode: Link access permission checking:
In this mode you provide a csv file with links to check, and wether those links should be accessible. The Link Crab will check every link in the list, determines if its accessible or not, and then assert the expected accessibilty to the actual accessibility. 
A link is considered accessible if the http response for a get request on the link has a status code under 400, and after all redirects, the url is equals of the starting url. 
(Most of the websites either give you a 404 or redirect to the sign-in page.)
*Maybe following the redirects is unnecessary, but I considered it safer*

## Session management:
In both workmode, you can provide login informations. The Link Crab opens up a Chrome browser with Selenium webdriver, and 

All reports are saved in the reports folder under a filder named by the domain name.
The configuration is done through a yaml config files.

## Installation

*soon...*

## Usage:
Simply use the command `link-crab/link-crab.py path/to/your/config.yaml` in the Link Crabs directory. All the configuration is done in the config files, which is expanded bellow.
If you want to use the sample flask mock app for testing, provide the `-t` flag.


### Usable config keys:
**starting_url**

    starting_url: http://127.0.0.1:5000

Gather the reachable links in the starting_url's page and all of its subpages.
After collecting all the links, the link exerciser load every in-domain url with a GET request, and measures 
status code, response time, response url after all redirects, and accessibility based on status code and response url

**path_to_link_perms**

    path_to_link_perms: testapp_member_access.csv

Test accessibility of provided links. The csv should have a link and a should-access column. 
asserts the link accessibility equals to provided should-access.
A link is accessible if the response status code<400, and after redirets the respone url equals the starting url
(some framework give a 404 for unaccessible pages or redriects to sign_in page)

**User**

    user:
        email: member@example.com
        email_locator_id: email
        login_url: http://127.0.0.1:5000/user/sign-in
        password: Password1
        password_locator_id: password
    
Login with the help of selenium webdriver (chromedriver). You need to provide the url of the login form, 
   and the id's of the email (or username) and password fields.
vui 0.0.4
GUI framework written in pure Python
Requires Python: >=3.6

# vui
vui is a cross-platform GUI framwork, built on top of Pyglet. It is currently
in early stage of development. The aim is to build a simple pythonic API that
could be used to build UI apps and games.

The framework is built around the hierarchy of UI elements represented by
classes inheriting from `View`. A view class can be attached to a (single)
`Pane` object. `Pane` is a simple class representing a rectangular area
in the window. This class also plays the role of host for mouse events.

Some of the views can contain other views. Such views are called "layouts".
A layout class is a `View` that contains the logic of subdiving its pane into
panes for its children.

Various UI classes are glued together with `Observable` values and attributes.
Functions and methods can be registed as listeners to an observable value. These
listeners are called whenever the value is changed. Most attributes of UI values
are observable, including pane dimentions, mouse position and so on.

In addition to `Observable` vui makes use of `events` module forked from Pyglet
events. As a rule, whenever an event can be thought about as changes of some
value, it should be represented as `Observable`. But some events like `on_draw`
don't fit this model and are represented as events.
supertype-python 1.1.0
A simple recursive function that allows to give more information about an object than 'type' binded function
Requires Python: >=3.6

## Overview

Supertype-python is a package containing a single function, supertype(). This one works like type but gives more information, which could be useful in a development phase.

## Installation

```bash
pip install supertype-python
```

## Usage

Without this package, it would take some precious time and precious attention to know the content of an object like this :

```python
a = [0,1,2]
b = 'bbb'
c = 5
d = {"x": "X", "y": "Y", "z": "Z"}
e = [a,b]
f = array('l', [1, 2, 3, 4, 5])
g = (f,e,c,d)
```
Now, you can import supertype() and just ask the supertype of the object f :
```python
from supertype import supertype

supertype(g)
```

This returns :

```
tuple of 4 elements containing : 
    -array of 5 elements containing {'int'}
    -list of 2 elements containing : 
        -list of 3 elements containing {'int'}
        -str of 3 elements
    -int
    -dict of 3 elements
```

This also works with objects from other librairies and even with you homemade objects !


## What should be added soon

-correction of language approximations\
-specific treatment for some types (not very useful to know the size of a string for example)\
-better comments\
-check compatibility with all python 3, see if it can go to python 2\
-...

If you have any idea or suggestion feel free to contact me on my email.

## Contributors

Martin Letzgus\
Antoine Thiol\
Quentin Petit

## License
[MIT](https://choosealicense.com/licenses/mit/)