semvec/pypi-packages huggingface dataset:
algo-fun-anagram 0.1.0
Check if 2 strings are anagram or not
License: MIT

# 🚀Anagram

## 📄Description

This is a project to tell if two strings are
anagram or not .

## ⚙️ Installation

clone the repository (git must be installed)
```
git clone https://gitlab.com/ChristopheLagaillarde/algo_fun_anagram.git 
```
or you can install it using pip

```
pip install algo-fun-anagram
```

or take the gz file on gitlab and use this command

```
tar -xzf algo_fun_anagram-0.1.0.tar.gz
```

## ✅Verification

You can have my public key on here: 
https://keyserver.ubuntu.com/pks/lookup?search=309F4D460B9BF1BD8DD31EAB39A61CA659ADD6E3&fingerprint=on&op=index

Take it and to verify that the integrity and authenticity of my project. You should be able to use this command to do so. 

```
gpg --verify algo_fun_anagram-0.1.0.tar.gz.asc algo_fun_anagram-0.1.0.tar.gz
```

## 🕹️Usage

You have to import it using this command

```
from algo_fun.is_anagram import is_anagram
```

You can use the function as follow

```
is_anagram("dog", "god")
```

## 📝LICENSE
Copyright (c) 2024 Christophe Lagaillarde 

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.
IMAPArchiver 1.0.0
The IMAPArchiver is a command-line tool that exports emails from your IMAP mailbox to a local folder, helping you keep your mailbox organized and your data backed up.
License: MIT
Requires Python: >=3.11
Keywords: imap email export backup archive

# IMAPArchiver

Have you ever found yourself in a situation where your IMAP mailbox is getting a bit too full, and you're concerned about losing important data?

The IMAPArchiver is here to ensure that no email goes missing. By exporting your emails to a local folder, you can safely backup your email data and store it in cloud storage solutions.

This enables easy access to old documents and provides a reliable backup solution for your important emails.

## Features

- Export emails from an IMAP mailbox to a local folder.
- Filter emails based on the specified year.
- Support for SSL connection.
- Option to skip specific IMAP folders.
- Verbose logging and debug mode for detailed output.

## Usage

Getting started is easy! Simply install IMAPArvchiver and configure the script with your IMAP server details and desired options, and run it. Your emails will be safely exported to the specified local folder, ready for backup or archiving.

Install:

```
pip install imaparchiver
```

Run IMAPArchiver with appropriate command-line arguments:

- `--server -s`: IMAP server address (required).
- `--user -u`: Username for IMAP authentication (required).
- `--password -p`: Password for IMAP authentication (required).
- `--destination -d`: Export folder path where emails will be saved (required).
- `--year -y`: Year to filter emails (optional).
- `--ssl`: Use SSL connection (optional).
- `--port`: Port number of the IMAP server (optional).
- `--skip`: Comma-separated list of IMAP folders to skip (optional).
- `--verbose`: Enable verbose logging (optional).
- `--debug`: Print debug output (optional).

Example:

```
imaparchiver -s imap.example.com -u john@example.com -p secret -d /path/to/export_folder -y 2022 --ssl --skip "Spam,Trash" --verbose
```

## Contribute

I welcome contributions from the community! If you've found a bug, have a feature request, or want to contribute code improvements, please submit an issue or pull request to this repository.

- Fork this repository.
- Create a branch: git checkout -b development.
- Make your changes and commit them: git commit -m '<commit_message>'
- Push to the original branch: git push origin flojud/IMAPArchiver
- Create the pull request.

Keep your mailbox organized and your data safe with the IMAPArchiver. Happy exporting!

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
tasnif 0.1.11
A simple library for unsupervised image clustering
License: MIT
Requires Python: >=3.9


<p align="center">
  <img src="assets/asdd.png" width="350" alt="accessibility text">
</p>


Tasnif is a Python package designed for clustering images into user-defined classes based on their visual content. It utilizes deep learning to generate image embeddings, Principal Component Analysis (PCA) for dimensionality reduction, and K-means for clustering. Tasnif supports processing on both GPU and CPU, making it versatile for different computational environments.

## Features

- Generate embeddings for images using a pre-trained model.
- Dimensionality reduction using PCA to enhance clustering performance.
- Clustering of images into user-specified classes with K-means.
- Visualization support by creating image grids for each cluster.
- Efficient image reading and preprocessing utilities.

## Installation

To install Tasnif, you need Python 3.6 or later. Clone this repository to your local machine and install the required dependencies:

```bash
pip install tasnif
```

## Usage

Import `Tasnif` and initialize it with the desired number of classes, PCA dimensions, and whether to use GPU:

```python
from tasnif import Tasnif

# Initialize Tasnif with 5 classes, PCA dimensions set to 16, and GPU usage
classifier = Tasnif(num_classes=5, pca_dim=16, use_gpu=False)
```

Read the images from a directory, calculate the embeddings, PCA, and perform K-means clustering:

```python
# Read images from a specified directory
classifier.read('path/to/your/images')

# Calculate embeddings, PCA, and perform clustering
classifier.calculate()
```

Finally, export the clustered images and visualization grids to a specified directory:

```python
# Export clustered images and grids
classifier.export('path/to/output')
```

## To-Do

- [x] Prevent calculation if there is no image read (PCA & k-means)
- [x] Export embeddings
- [ ] Make model independent from img2vec
- [ ] Separate cpu and gpu installation and catch gpu errors


## Contributing

Contributions to `Tasnif` are welcome! Please fork the repository and submit a pull request with your proposed changes.

## License

Tasnif is released under the MIT License. See the [LICENSE](LICENSE) file for more details.
Gh0stSimpleDiagramTool 0.0.4
A simple diagram drawing tool
License: MIT
Keywords: diagram flowchart matplotlib

# SimpleDiagramTool

`SimpleDiagramTool` is a Python class that provides a simple interface for creating diagrams using matplotlib. It allows you to add blocks, lines, and arrows to a diagram, and then display the diagram.

## Installation

This tool requires matplotlib to be installed. You can install it using pip:

```bash
pip install matplotlib
```

## Usage

First, import the `SimpleDiagramTool` class:

```python
from simple_diagram_tool import SimpleDiagramTool
```

Then, create an instance of the class, specifying the length and width of the diagram:

```python
diagram = SimpleDiagramTool(10, 10)
```

### Adding a block

You can add a block to the diagram using the `add_block` method. This method takes the following parameters:

- `position`: A tuple `(x, y)` specifying the bottom left corner of the block.
- `size`: A tuple `(width, height)` specifying the size of the block.
- `label`: A string label for the block.
- `boundary_color`: (optional) The color of the block boundary. Default is 'r' (red).
- `text_size`: (optional) The size of the label text. Default is 10.

```python
diagram.add_block((1, 1), (2, 2), 'Block 1', boundary_color='b', text_size=12)
```

### Adding a line

You can add a line to the diagram using the `add_line` method. This method takes the following parameters:

- `start_pos`: A tuple `(x, y)` specifying the start position of the line.
- `end_pos`: A tuple `(x, y)` specifying the end position of the line.
- `line_color`: (optional) The color of the line. Default is 'k' (black).

```python
diagram.add_line((1, 1), (3, 3), line_color='g')
```

### Adding an arrow

You can add an arrow to the diagram using the `add_arrow` method. This method takes the following parameters:

- `start_pos`: A tuple `(x, y)` specifying the start position of the arrow.
- `end_pos`: A tuple `(x, y)` specifying the end position of the arrow.
- `arrow_color`: (optional) The color of the arrow. Default is 'k' (black).

```python
diagram.add_arrow((1, 1), (3, 3), arrow_color='r')
```

### Displaying the diagram

Finally, you can display the diagram using the `show` method:

```python
diagram.show()
```

## Error Handling

If you try to add an element that is out of the bounds of the diagram, a `ValueError` will be raised. Make sure that all elements fit within the specified length and width of the diagram.

## Examples

Here's a complete example that creates a diagram with a block, a line, and an arrow:

```python
from simple_diagram_tool import SimpleDiagramTool

diagram = SimpleDiagramTool(10, 10)
diagram.add_block((1, 1), (2, 2), 'Block 1', boundary_color='b', text_size=12)
diagram.add_line((1, 1), (3, 3), line_color='g')
diagram.add_arrow((1, 1), (3, 3), arrow_color='r')
diagram.show()
```

This will create a 10x10 diagram with a blue block labeled 'Block 1' at position (1, 1) with size (2, 2), a green line from (1, 1) to (3, 3), and a red arrow from (1, 1) to (3, 3).