semvec/pypi-packages huggingface dataset:
DiagramTool 1.0.2
A tool to create diagrams from code
Requires Python: >=3.11

# Diagram Tool

## Description

Python script for creating UML diagrams from source code.
- Can parse multiple languages:
    - Python
    - Javascript (not yet implemented)
    - Typescript (not yet implemented)
- Generate a SVG file with the diagram


## Usage

### Command Line
Use `diagramTool` command to generate the diagram.
```bash
diagramTool [options] <source> <output>
```

#### Options
use ```diagramTool --help``` to see the available options:

```
usage: DiagramTool [-h] [--debug] [--dump] [--save-ast] source output

create a class diagram from source code

positional arguments:
  source      source code main file
  output      output file

options:
  -h, --help  show this help message and exit
  --debug     print debug information
  --dump      dump parsed data to stdout
  --save-ast  save ast to file
```

### From Python
```python
import diagramTool as dt

dt.fromSource(source, output, save_ast=False, dump=False, showBorder=False)
```


## Example

![Example](example.svg)

Class diagram of this project generated with the tool.
woopyMysql 0.1
Simple class to manage multiple Mysql Db with mysql-connector-python
Requires Python: <3.13,>=3.6

# WoopyMysqlAuth Class

![Python](https://img.shields.io/badge/Python-3.10%2B-blue)
[![GitHub](https://img.shields.io/badge/GitHub-WoppyMysql-black)](https://github.com/woopygit/woopyMysql)
[![Wppy.net](https://img.shields.io/badge/WpPy.net-WoppyMysql-black)](https://www.wppy.net/woopyMysql)

## Overview

The `WoopyMysqlAuth` class is designed to manage and validate the authentication credentials needed to connect to a MySQL database. It supports loading credentials from an environment file or directly from a dictionary. The class ensures that all required credentials are provided and valid before establishing a database connection.

## Features

- Load database credentials from a `.env` file or a provided dictionary.
- Validate the presence of all necessary credentials.
- Establish a connection to the MySQL database.

## Usage

### Initialization

The class can be initialized in two ways:
1. Using a dictionary containing the authentication credentials.
2. Loading credentials from a `.env` file.

#### Example 1: Initializing with a Dictionary

```python
WoopyAuth = {
    "woopy_db_host_ip": "127.0.0.1",
    "woopy_db_name": "example_db",
    "woopy_db_user_name": "root",
    "woopy_db_user_password": "password",
    "woopy_db_table_prefix": "wp_"
}

auth = WoopyMysqlAuth(WoopyAuth=WoopyAuth)
```
#### Example 2: Initializing with an Environment File
```python
auth = WoopyMysqlAuth(WoopyEnv='.env')
```
## Websites using 'woopy' library:
- [OffertaLampo.net](https://www.offertalampo.net)
- [PriceErrors.net](https://www.priceerrors.net)
- [Cpaff.net](https://www.cpaff.net)
- [Promozioni.net](https://www.promozioni.net)
- [buoni.net](https://www.buoni.net)
- [Polignano.net](https://www.polignano.net)
- [Trullit.com](https://www.trullit.com)
- [wppy.net](https://www.wppy.net)
pyfxr 0.2.0
SFXR clone using Pygame and Cython

# pyfxr

Sound effects generation for Python, compatible with Pygame and Pyglet.


## Installation

`pyfxr` is on PyPI and pre-compiled for Mac, Windows and Linux. You can install
the library with

```
pip install pyfxr
```

## Documentation

[Full API documentation](https://pyfxr.readthedocs.io/)


## Pygame Usage

```
# Set mixer to 44kHz mono
pygame.mixer.pre_init(44100, channels=1)

# Generate a sound
tone = pygame.mixer.Sound(
    buffer=pyfxr.pluck(duration=1.0, pitch='A4')
)

# Play it
tone.play()
```

## Usage with Pyglet

```
# Generate a random explosion sound
explosion = pyglet.media.StaticSource(pyfxr.explosion())

# Play it
explosion.play()
```

## Usage with sounddevice

```
import sounddevice
import pyfxr

sounddevice.play(pyfxr.jump(), pyfxr.SAMPLE_RATE)
```

## GUI

A Pygame GUI is in development, to explore the feature set and create music!

To install the Pygame-based GUI along with the library, use:

```
pip install pyfxr[gui]
```

Then you can run the GUI by running `pyfxr`.

![Screenshot](docs/_static/keyboard.png)
theport 2.1.1
A library for scanning ports and identifying services
Requires Python: >=3.6

# ThePort 2.1.1

ThePort is a Python library for scanning ports and identifying running services on a specified IP address. It allows users to find open ports and check their statuses.

- By using this tool you can scan ports very deep and list ports
  
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
  - [Basic Port Scanning](#basic-port-scanning)
  - [Scanning with User-Defined Ports](#scanning-with-user-defined-ports)
  - [Scanning All Ports](#scanning-all-ports)
  - [Asynchronous Scanning](#asynchronous-scanning)
- [Available Ports](#available-ports)
- [License](#license)
- [Contributing](#contributing)
- [Acknowledgments](#acknowledgments)

## Installation

To install ThePort, you can use pip:

```bash
pip install theport
```

## Usage

### Basic Port Scanning

To scan ports on a specific IP address and print the status of each port:

```bash
from theport import scan_ports

# Example IP address to scan
ip_address = '199.36.158.100'

# Custom list of ports to scan
custom_ports = [22, 80, 443, 3306, 8080]

# Start scanning
open_ports, closed_ports = scan_ports(ip_address, custom_ports)

# Print results
for port, service in open_ports:
    print(f"Port {port} is open: {service}")

for port in closed_ports:
    print(f"Port {port} is closed")
```

### Scanning with User-Defined Ports

You can specify your own list of ports to scan as follows:

```bash
from theport import scan_ports

# Example IP address to scan
ip_address = '199.36.158.100'

# Custom list of ports to scan
custom_ports = [21, 25, 80, 443]

# Start scanning
open_ports, closed_ports = scan_ports(ip_address, custom_ports)

# Print results
for port, service in open_ports:
    print(f"Port {port} is open: {service}")

for port in closed_ports:
    print(f"Port {port} is closed")
```

### Scanning All Ports

To scan all ports in the full range (1-65535):

```bash
from theport import scan_ports

# Example IP address to scan
ip_address = '199.36.158.100'

# Start scanning all ports
open_ports, closed_ports = scan_ports(ip_address)

# Print results
for port, service in open_ports:
    print(f"Port {port} is open: {service}")

for port in closed_ports:
    print(f"Port {port} is closed")
```

## Available Ports

ThePort supports a variety of commonly used ports, including but not limited to:

- **HTTP**: 80
- **HTTPS**: 443
- **FTP**: 21
- **SMTP**: 25, 587
- **MySQL**: 3306
- **SSH**: 22
- **Telnet**: 23
- **RDP**: 3389
- **PostgreSQL**: 5432
- **Redis**: 6379
- **MongoDB**: 27017

Feel free to extend the list as per your needs.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

If you would like to contribute to ThePort, please open an issue or submit a pull request. Any help is greatly appreciated!

## Acknowledgments

Thank you for using ThePort! We appreciate your interest and support. If you find any issues or have suggestions, please let us know.
apccapi 0.0.1
APCC Climate Information toolKit API package
Requires Python: >=3.6
Keywords: APCC, apcc, Climate, Climate Information, Climate API

## Installation

Install via pip with:

```bash
$ pip install apccapi
```

## Configure (Linux)

Obtain your API key from the CLIK (Climate Information toolKit) at https://cliks.apcc21.org and enter it into the apccapi.properties file, formatting it as follows:

```
$ vi ~/.apccapi.properties

key={your API key}
request_url=https://request.apcc21.org/apccdata
status_url=https://request.apcc21.org/status
```

## Configure (Windows)

Obtain your API key from the CLIK (Climate Information toolKit) at https://cliks.apcc21.org, and create the apccapi.properties file in your Windows Home directory (typically C:\Users\YourUserName) with the following format:

```
key={your API key}
request_url=https://request.apcc21.org/apccdata
status_url=https://request.apcc21.org/status
```

## Test

Perform a small test retrieve of MME data:
```
$ python
>>> import apccapi
>>> c = apccapi.Client()
>>> c.retrieve(
	{
		'jobtype': 'MME',
		'dataset': 'MME_3MONTH',
		'type': 'FORECAST',
		'method': 'SCM',
		'variable': ['prec', 't2m'],
		'period': ['Monthly mean'],
		'yearmonth': ['201909']
	},
	'mme3.zip'
)
>>>

```

## License

MIT License

Copyright (c) 2019 - 2024, APEC Climate Center

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
fc-nmap 0.0.10
Farcaster network mapping
Requires Python: >=3.8

# fc-nmap

**THis software is still in alpha and under heavy development.** Things will change and break.

[![PyPI - Version](https://img.shields.io/pypi/v/fc-nmap.svg)](https://pypi.org/project/fc-nmap)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fc-nmap.svg)](https://pypi.org/project/fc-nmap)

-----

![world map of hubs](map.png)

## Quickstart

```console
pip install fc-nmap

fc-nmap --help

Usage: fc-nmap [OPTIONS] COMMAND [ARGS]...

  Farcaster Network Mapper

Options:
  --version   Show the version and exit.
  -h, --help  Show this message and exit.

Commands:
  exportdb  Create a tab separated dump of the database
  initdb    Initialize the database
  scan      Scan will scan the network
  updatedb  Collect addtional information about each hub
  map       Create a mpa of the hubs in db
```

## Behind the scenes

`fc-nmap initdb` creates a local sqlite database where data is stored.

`fc-nmap scan` will start by asking a hub to provide its contact list (gRPC call `GetCurrentPeers`). Using this list, it will pick `--hops`
hubs at random, and request their contact list too. The lists are combined and stored in the database.

`fc-nmap updatedb --hub-info` looks into the database and picks hubs that were recently active.
(Recency is defined by comparing `ContactInfoContentBody.timestamp` collected when requesting the contacts lists and the current timestamp.)
The command will try to connect to each one of the hubs, and collect additional info using `GetInfo`, and store the results in the local
database.

`fc-nmap updatedb --hub-location` works similar to `--hub-info`, but uses ip2location.io to get location information about each hub IP.
Again, information collected is stored in the local database. The script will not query ip2location for IPs that were looked up in the last
100 days. This helps staying within ip2location free plan limits.

`fc-nmap export --report=all` will export all "active" hubs. Use fc-nmap export --help` to get all the available exports/reports.
Or connect directly to the local database (currently named hubs.db and stored in the directory where you called the previous commands)
and run your own queries.

## License

`fc-nmap` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.