semvec/pypi-packages huggingface dataset:
gods-eye 1.2.0
A set of tools which should be used in Gods Eye

[![Build, Test, Deploy](https://github.com/paveldat/Gods-eye/actions/workflows/deploy-job.yml/badge.svg)](https://github.com/paveldat/Gods-eye/actions/workflows/deploy-job.yml)

# GOD'S EYE
God's EYE - Information Gathering Tool.
God's EYE is an Information Gathering Tool I made in python3.10.

## Library installation
All modules located in the `src` directory are APIs, so you can build a library from the sources and use it in your projects.

### 1. How to build a library from sources
1) Clone this repo
```shell
git clone https://github.com/paveldat/God-s-eye.git
```
2) Go to the cloned repository
```shell
cd God-s-eye
```
3) Install deb- and py-requirements
```shell
pip install -r py-requirements.txt
xargs sudo apt-get install <deb-requirements.txt
```
4) Run the following command
```shell
python3 -m build .
```
5) Now you can install library
```shell
pip install dist/gods_eye-<version>-py3-none-any.whl
```

### 2. Installation from `releases`
1) Download `.whl` file form releases
2) Run the following command:
```shell
pip install <downloaded_file>.whl
```

### 3. Installation from `PyPI`
```shell
pip install gods-eye
```

## Tools
1. Clickjacking - Checks if the clickjacking is possible on any Domain.
2. DnsLookup - Looks for dns lookup information for IP or Domain.
3. exec_shell_command - Common method to execute shell commands.
4. HttpHeadersGrabber - Looks for HTTP Headers.
5. GetHostname - Gets hostname and IP.
6. IpInfoFinder - Gets information by IP or Domain. Info: ip, status, region, country, country code, region, region name, city, zip, lat, lon,
timezone, isp, org, as.
7. Logger - Logger. The Logger has 2 handlers:
    * stream handler into console;
    * file handler into file.
8. OneSecMail - Creates one-time temporary mail.
9. PhoneInfo - Gets info by phone number.
10. PasswordPwned - Checks if password has been compromised in a data breach.
11. RobotsScanner - A robots.txt file tells search engine crawlers which URLs the crawler can access on your site. This class will search for this file, parse it and return the result.
12. WhoisLookup - Search for IP WHOIS information using the IP WHOIS lookup tool for any allocated IP address.

## How to use
Now you can use this library. To connect a module to your project, just import it.
All modules can be found in the `src` directory.

Example:
```python
from clickjacking.clickjacking import ClickJacking
```

It is not difficult to guess that the following template is used here:
`from <directory>.<filename> import <class_name>`
For example:
`from clickjacking.clickjacking import ClickJacking`

Be careful, we don't use the `src` directory anymore.

## PyPI
https://pypi.org/project/gods-eye/
trustworthyai-text 0.2.12
SDK API to assess text Machine Learning models.
Requires Python: >=3.7

# Trustworthy AI Text SDK for Python

### This package has been tested with Python 3.7, 3.8 and 3.9

The Trustworthy AI Text sdk enables users to analyze their machine learning models for text data in one API. Users will be able to analyze errors, explain the most important features, and understand their data using a single API.

Highlights of the package include:

- `explainer.add()` explains the model

### Supported scenarios, models and datasets

The Trustworthy AI Text SDK supports multiclass classification and question answering models on text data currently.

The open source code for the visualization dashboard can be found here:
https://github.com/affectlog/trustworthy-ai-toolbox
trustworthyai-vision 0.3.10
SDK API to assess image Machine Learning models.
Requires Python: >=3.7

# Trustworthy AI Vision SDK for Python

### This package has been tested with Python 3.7, 3.8 and 3.9

The Trustworthy AI Vision SDK enables users to analyze their machine learning models for computer vision in one API. Users will be able to analyze errors, explain the most important features, and understand their data using a single API.

Highlights of the package include:

- `explainer.add()` explains the model

### Supported scenarios, models and datasets

The Trustworthy AI Vision SDK supports multiclass classification models on image data currently.

The open source code for the visualization dashboard can be found here:
https://github.com/affectlog/trustworthy-ai-widgets
tai-test-utils 0.4.4
Common basic test utilities used across various TAI tools
Requires Python: >=3.7

# Trustworthy AI test utilities for Python

### This package has been tested with Python 3.7, 3.8, 3.9, 3.10 and 3.11

The Trustworthy AI Test Utilities package contains common testing utilities and functions shared across various TAI tools, including fairlearn, interpret-community, trustworthyai, affectlog_widgets, ml-wrappers and other packages.

Please see the main documentation website:
https://trustworthyaitoolbox.ai/

The open source code can be found here:
https://github.com/affectlog/trustworthy-ai-toolbox
tai-core-flask 0.7.8
Trustworthy AI Core Flask Wrapper

# tai_core_flask

Provide environment detection for enabling Flask server without configuring at instantiation. Environments are implemented as classes that will either return None if the environment check fails, or return an object with all the appropriate environment settings if the check passes. The flask service can then use it to build out urls, attach required headers, and render inline visualizations with the correct methods.

## Installation

`pip install -e .`

## Usage

`from tai_core_flask import FlaskHelper`
`flask_service = FlaskHelper(ip=<ip-to-listen-on>, port=<port-to-listen-on>)`

If `ip` is not specified then it listens on `localhost` by default.
If `port` is not specified then it finds an open port in the range 8704 to 8993
and listens on it.

To register a function to listen on an route:

```
@flask_service.app.route("/your-api-route/<int:param_name>", methods=["GET", "POST"])
def my_func(param_name):
    return something
```

## Release Process

1. Increment the version number in `setup.py`
2. Activate your virtual environment.
3. Run the `release.sh` script.
affectlog-utils 0.4.4
Common basic utilities used across various TAI tools
Requires Python: >=3.7

# Trustworthy AI Utilities for Python

### This package has been tested with Python 3.7, 3.8, 3.9, 3.10 and 3.11

The Trustworthy AI Utilities package contains common functions shared across various TAI tools, including fairlearn, interpret-community, trustworthyai, affectlog_widgets and other packages, as well as notebook examples.

Please see the main documentation website:
https://trustworthyaitoolbox.ai/

The open source code can be found here:
https://github.com/affectlog/trustworthy-ai-widgets
affectlog-feature-extractors 0.2.1
AffectLog NLP Feature Extractors

# NLP Feature Extractors SDK for Python

### This package has been tested with Python 3.7, 3.8 and 3.9

The NLP Feature Extractors project enables the tabular components in the TAI tools to be applied to Natural Language Processing (NLP)
tasks on unstructured text.

Please see the main documentation website:
https://trustworthyaitoolbox.ai/

The open source code can be found here:
https://github.com/affectlog/trustworthy-ai-widgets
affectlog-erroranalysis 0.5.7
Core error analysis APIs
Requires Python: >=3.7

# Error Analysis SDK for Python

### This package has been tested with Python 3.7, 3.8, 3.9, 3.10 and 3.11

The error analysis sdk enables users to get a deeper understanding of machine learning model errors. When evaluating a machine learning model, aggregate accuracy is not sufficient and single-score evaluation may hide important conditions of inaccuracies. Use Error Analysis to identify cohorts with higher error rates and diagnose the root causes behind these errors.

Highlights of the package include:

- The error heatmap to investigate how one or two input features impact the error rate across cohorts
- The decision tree surrogate model trained on errors to discover cohorts with high error rates across multiple features. Investigate indicators such as error rate, error coverage, and data representation for each discovered cohort.

Auto-generated sphinx API documentation can be found here:
https://affectlog_erroranalysis.ai/affectlog_widgets.html

The open source code can be found here:
https://github.com/affectlog/trustworthy-ai-widgets
impyrialaremou 0.3.0
A package for converting impyrial lengths and weights.

## impyrialaremou

A package for converting between imperial unit lengths and weights.

This package was created for the [DataCamp](https://www.datacamp.com) course "Developing Python Packages".

### Features

- Convert lengths between miles, yards, feet and inches.
- Convert weights between hundredweight, stone, pounds and ounces.

### Usage

```python
import impyrialaremou

# Convert 500 miles to feet
impyrialaremou.length.convert_unit(500, from_unit='yd', to_unit='ft')  # returns 1500.0

# Convert 100 ounces to pounds
impyrialaremou.weight.convert_unit(100, from_unit='oz', to_unit='lb')  # returns 6.25
```
VoidHangman 0.1.1
A simple Hangman game module for Discord bots
Requires Python: >=3.6

## Usage
Here's how you can use the Hangman class in your Discord bot:

```python```
# Import the Hangman class
from void-hangman import Hangman

# Create a new game instance
game = Hangman()

# Make a guess
result = game.guess('a')  # Guess a letter


current_word = game.get_display_word()  # This will show the current guessed letters

# Check if the game is over
if game.is_game_over():
    if game.is_word_guessed():
        print("You've guessed the word!")
    else:
        print("Game over! The word was:", game.word)

## Methods
- `__init__(self)`: Initializes a new Hangman game with a random word and resets attempts.
- `guess(letter)`: Takes a letter as input, checks if it's in the word, and updates the game state.
- `get_display_word()`: Returns the current state of the word with guessed letters revealed.
- `is_game_over()`: Checks if the game is over (either the word is guessed or attempts are exhausted).
- `is_word_guessed()`: Checks if the player has successfully guessed the word.
- `get_attempts_left()`: Returns the number of attempts left.
- `get_hangman_visual()`: Returns the current visual representation of the hangman based on attempts left.
pywolt 0.1.0
PyWolt is a Python library that provides an open API for interacting with the popular food delivery application Wolt.
Requires Python: >=3.9

# PyWolt

PyWolt is a Python library that provides an open API for interacting with the popular food delivery application Wolt. It utilizes the native, internal Wolt web API and wraps it in a Pythonic interface.

## Features

- **List Available Venues**: Retrieve a list of available venues for a given set of coordinates.
- **Search Venues**: Search for venues based on coordinates and a text query.
- **Search Food Items**: Search for food items based on coordinates and a text query.
- **List Venue Menu**: Retrieve the menu of a specific venue.
- **List Cities**: Retrieve a list of cities and their coordinates using Wolt's buit-in api
Upcoming Features:
- **Authentication**: Authenticate to get access to the user's basket and make orders.

## Usage Examples

### Get Venues
```python
from pywolt.api import Wolt
import asyncio

# Initialize Wolt instance with latitude and longitude
wolt = Wolt(lat="35.0844", lon="106.6504")

# Get venues available at specified coordinates
venues = asyncio.run(wolt.get_venues())

# Get details of a specific venue (e.g., Los Pollos Hermanos)
los_pollos = venues[0]

print(los_pollos.venue.name)
```
```python
Los Pollos Hermanos
```

### Get the menu of the venue
```python
los_pollos_menu = asyncio.run(wolt.get_menu(los_pollos.venue.slug))
```

### Search Venues
```python
los_pollos_menu = asyncio.run(wolt.search_venues("pizza"))
```
### Search Items
```python
los_pollos_menu = asyncio.run(wolt.search_items("pizza"))
```
### Get Cities
```python
los_pollos_menu = asyncio.run(wolt.get_cities())
```


## License

This project is licensed under the [Creative Commons Attribution-NonCommercial-ShareAlike (CC BY-NC-SA) 4.0 International License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
void-Hangman 0.0.1
A simple Hangman game module for Discord bots
Requires Python: >=3.6

## Usage
Here's how you can use the Hangman class in your Discord bot:

```python```
# Import the Hangman class
from void-hangman import Hangman

# Create a new game instance
game = Hangman()

# Make a guess
result = game.guess('a')  # Guess a letter


current_word = game.get_display_word()  # This will show the current guessed letters

# Check if the game is over
if game.is_game_over():
    if game.is_word_guessed():
        print("You've guessed the word!")
    else:
        print("Game over! The word was:", game.word)

## Methods
- `__init__(self)`: Initializes a new Hangman game with a random word and resets attempts.
- `guess(letter)`: Takes a letter as input, checks if it's in the word, and updates the game state.
- `get_display_word()`: Returns the current state of the word with guessed letters revealed.
- `is_game_over()`: Checks if the game is over (either the word is guessed or attempts are exhausted).
- `is_word_guessed()`: Checks if the player has successfully guessed the word.
- `get_attempts_left()`: Returns the number of attempts left.
- `get_hangman_visual()`: Returns the current visual representation of the hangman based on attempts left.
pykite 1.0.1
A Python-centric micro-framework for building web applications
Keywords: pykite, web framework, micro framework, web applications, Python, HTTP, WSGI

### PyKite: A research and development initiative for crafting a Python-centric micro framework.

[//]: # (![Pykite, the Python framework]&#40;./extras/yellow-kite.png&#41;)
![PyKite Icon](https://raw.githubusercontent.com/ImamHossainRoni/pykite/main/extras/yellow-kite.png)

## Features

- **Route Definition:** Define routes using the `@app.route(path)` decorator.

- **HTTP Request Handling:** Create handler functions for each route to process and respond to incoming HTTP requests.

- **Development Server:** Start a development server with a single command, making it easy to test your application locally.

- **Basic Error Handling:** Includes a default 404 response for routes that are not found.


## Installation
To get started with PyKite, follow these steps:
```bash
pip install pykite
```
## Run the application
1. Create a Python script for your web application using PyKite. Define routes and handlers as needed.
2. Run your application using the `run` method:

```python
from pykite import PyKite
from pykite.http.response import Response

# Create a PyKite application
app = PyKite(debug=True)


# Define a route for the '/' path
@app.route('/')
def index(request, response):
    """Respond with a JSON object containing the message "Hello, World!" to all requests to the '/' path."""
    data = {"message": "Hello, World!"}
    response = Response(data=data, status=200)
    return response


@app.route('/hello/{name}')
def hello(request, response, name):
    """ Took a name from the URL and responds with a friendly greeting in JSON."""
    data = {"message": f"Hello, {name}"}
    response = Response(data=data, status=200)
    return response


# Run the application
if __name__ == "__main__":
    app.run()

```
3. Access your application in a web browser at http://localhost:8000.

## Middleware
Middleware in web development refers to software components that sit between a web server and an application. They intercept requests and responses, allowing for additional processing or modification before they reach the application or client. Middleware can be used for tasks like authentication, authorization, logging, caching, and more. Let's see [ 👉 how to use middleware in `PyKite`](docs/middleware.md)  framework. 


## License

This project is licensed under the [MIT License](LICENSE).