semvec/pypi-packages huggingface dataset:
fastldpmst 1.0.0
FastLDPMST is an efficient density-based clustering method for large-size datasets.

# FastLDPMST

### *FastLDPMST* is an efficient density-based clustering method for large-size datasets.

>**Teng Qiu, Yongjie Li, IEEE Transactions on Knowledge and Data Engineering, 2022, DOI: 10.1109/TKDE.2022.3150403.**

Cluster analysis is widely studied and used in diverse
fields. Despite that
many clustering methods have been proposed, it is rare for a clustering
method to perform well simultaneously on the following characteristics:  
* effectiveness (in terms of accuracy);
* efficiency (in terms of speed);
* robustness (in terms of noise and parameter sensitivity);
* user-friendliness (in terms of the number of user-specified parameters,
interpretability, and reproducibility of the results, etc.). 

This work contributes to the field of clustering by providing a new solution (i.e., Fast LDP-MST) which largely improves the efficiency of LDP-MST, without sacrificing the merits of LDP-MST in effectiveness, robustness, and user-friendliness. 
Fast LDP-MST achieves a good balance among effectiveness, efficiency, robustness, and user-friendliness, and thus it could
have a certain degree of practical value in this big data era.

#### The implementation of the MATLAB version can be accessed through the link: https://github.com/Teng-Qiu-Clustering/Fast-LDP-MST-Clustering-IEEE-TKDE-2022
sqlton 0.1.19
Parse SQL statement into straight forward Syntax Tree.
Requires Python: <4.0,>=3.11

# SQLTOn

SQLTOn parse sql statements (according to Sqlite3 gramar description) into a easily browseable/processable tree.

```python
from sqlton import parse
from sqlton.ast import Select

statement = parse('select Something from SomeTable whern SomethingElse=SomeValue')
if not isinstance(statement, Select):
	print('only select statement are accepted')
	exit()
	
if not hasattr(statement, 'limit'):
	print('select statement shall have a limit clause !')
	exit()
	
def compute(expression):
	...
	
if compute(statement.limit[0]) > 100:
	print('too much entry requested !')
```
leonardo-wrapper 1.0.1
A wrapper for the leonardo.ai image generation
Requires Python: >=3.6

# Image Generation with Leonardo Library

This document outlines the process of generating images using the `Leonardo` library in Python, as demonstrated in the provided code snippet.

## Overview

The code snippet demonstrates how to use the `Leonardo` class from the `lib.leonardo` module to generate an image based on a textual prompt. The example generates an image of a fantastical scene inside an ancient, otherworldly library.

## Steps

1. **Initialization**: The `Leonardo` class is initialized with a username and password.

    ```python
    from lib.leonardo import Leonardo

    leonardo = Leonardo(username="your_username", password="your_password")
    ```

    > **Note**: Replace `your_username` and `your_password` with your actual credentials.

2. **Creating an Image Generation Request**: An image generation request is created with specific parameters such as the prompt, number of images, model ID, model version, image dimensions, and guidance scale.

    ```python
    get_generation_id = leonardo.create_generate_image(
        prompt="Create a fantastical and visually stunning scene inside an ancient, otherworldly library...",
        amount_of_images=1,
        model_id="model_id",
        sd_version="model_version", # for some models you have to provide the sd_version
        width=1024,
        height=768,
        guidance_scale=7
    )
    ```

    > **Note**: Replace `model_identifier` and `model_version` with the specific model ID and version you wish to use. For a list of available models and their versions, see [models.md](models.md). Please note that you can run `gen_models_md.py` to update the documentation with the latest model information.
    

3. **Waiting for Image Generation**: The script waits for the image generation process to complete.

    ```python
    leonardo.wait_for_image_generation(creation_id=get_generation_id)
    ```

4. **Retrieving the Generated Image**: The generated image is retrieved, and its details are printed.

    ```python
    generated_image = leonardo.get_image_generation(creation_id=get_generation_id)

    print(generated_image)
    print(generated_image["generated_images"][0]["url"])
    ```

## Conclusion

This guide introduces the fundamental steps for generating images with the Leonardo library. It encompasses the initialization of the Leonardo class, formulation of an image generation request, supervision of account management throughout the generation phase, and the final retrieval of the created image.
FastLDPMST 1.0.1
FastLDPMST is an efficient density-based clustering method for large-size datasets.

# FastLDPMST

### *FastLDPMST* is an efficient density-based clustering method for large-size datasets.

>**Teng Qiu, Yongjie Li, IEEE Transactions on Knowledge and Data Engineering, 2022, DOI: 10.1109/TKDE.2022.3150403.**

Cluster analysis is widely studied and used in diverse
fields. Despite that
many clustering methods have been proposed, it is rare for a clustering
method to perform well simultaneously on the following characteristics:  
* effectiveness (in terms of accuracy);
* efficiency (in terms of speed);
* robustness (in terms of noise and parameter sensitivity);
* user-friendliness (in terms of the number of user-specified parameters,
interpretability, and reproducibility of the results, etc.). 

This work contributes to the field of clustering by providing a new solution (i.e., Fast LDP-MST) which largely improves the efficiency of LDP-MST, without sacrificing the merits of LDP-MST in effectiveness, robustness, and user-friendliness. 
Fast LDP-MST achieves a good balance among effectiveness, efficiency, robustness, and user-friendliness, and thus it could
have a certain degree of practical value in this big data era.

#### The implementation of the MATLAB version can be accessed through the link: https://github.com/Teng-Qiu-Clustering/Fast-LDP-MST-Clustering-IEEE-TKDE-2022
AuthoRex 1.0.2
A package for generating and authenticating OTPs using MongoDB.
Requires Python: >=3.6
Keywords: OTP, authentication, MongoDB, OTP generator, OTP authenticator

# AuthoRex

AuthoRex is a Python package for generating and authenticating OTPs (One-Time Passwords) using MongoDB for storage. This package is useful for applications that require secure OTP-based authentication.

## Features

- Generate OTPs.
- Authenticate OTPs.
- Uses MongoDB for storing OTPs securely.

## Installation

You can install AuthoRex using pip:

```sh
pip install AuthoRex
```

## Usage

### Importing the package

You can import the entire package or specific functions:

```python
import AuthoRex

# Or import specific functions
from AuthoRex import genOTP, authOTP
```

### Generating an OTP

Generate an OTP for a given number:

```python
# Using the package import
print(AuthoRex.genOTP("123"))

# Using the function import
print(genOTP("123"))
```

### Authenticating an OTP

Authenticate an OTP for a given number:

```python
# Using the package import
print(AuthoRex.authOTP("123", 123456))  # Replace 123456 with the actual OTP generated

# Using the function import
print(authOTP("123", 123456))  # Replace 123456 with the actual OTP generated
```

## Example

Here's a complete example of how to use AuthoRex:

```python
import AuthoRex

# Generate OTP for a number
response = AuthoRex.genOTP("123")
print(response)

# Authenticate OTP for the same number
is_authenticated = AuthoRex.authOTP("123", 123456)  # Replace 123456 with the actual OTP generated
print("Authenticated" if is_authenticated else "Authentication Failed")
```

## MongoDB Configuration

AuthoRex uses MongoDB to store OTPs. Make sure you have a MongoDB instance running and update the MongoDB URI in the code as per your setup.

## License

This project is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License. See the [LICENSE](https://github.com/TraxDinosaur/AuthoRex/blob/main/LICENSE) file for more details.

## Author

AuthoRex is developed and maintained by [TraxDinosaur](https://github.com/TraxDinosaur). For any queries or support, you can reach out to [TraxDinosaur](https://traxdinosaur.github.io).

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request for any improvements or bug fixes.

## Acknowledgements

- The package uses [pymongo](https://pypi.org/project/pymongo/) for MongoDB interactions.