semvec/pypi-packages huggingface dataset:
tecoradors-elunico 8.3.1
A small collection of decorators I like to use often
Requires Python: >=3.10

# Tecoradors

Python decorators that I like to use a lot.

[Find the github repo here](https://github.com/elunico/tecoradors)

[Find the pypi package here](https://pypi.org/project/tecoradors-elunico/)

Named based on my name which starts with a T. You can find more information reading the docstrings of the functions.

**Information on how to use these decorators can be found in their docstring**
Using `help(tecorador)` is a good way to learn about them. You can also read their docs on Github

### Decorators are

- Enforcer **\*(new in 7.0.0!)**: subclassable and customizable annotation type checking enforcer: pass instance to @enforce_annotations decorator to customize its behavior
- CompositeEnforcer **\*(new in 7.0.0!)**: Allows multiple Enforcer objects to work together in sequence\*
- ~~EnforceAnnotations~~ **\*(Removed in 7.0.0)**: use pluggable Enforcer objects and @enforce_annotations function decorator\*
- enforce_annotations **\*(new in 6.3.0!)**: Enforces type annotations on arguments and return types at runtime. Replaces @accepts and @returns. Customizable with custom Enforcer sublcasses
- deprecated
- accepts
- returns
- interruptable
- json_serializable
- spread
- builder
- tattle
- timed
- squash
- stringable
- equatable
- hashable
- orderable
- dataclass
- final
- freeze
- log
- synchronized
- count_calls
- lazy
- precompute
- resultify
- exc_to_bool
- decurryable

### Support from types

- Self
- PredicateType
- TattleOptions
- FrozenClassError
- PrecomputeStorage
- NoSuchValue
ssh-keyconv 0.9.0
SSH Key Conversion Utility
Requires Python: >=3.12
Keywords: ssh, openssh, pem, der, pkcs8, private key

# ssh-keyconv

ssh-keyconv is a SSH key conversion utility that can convert SSH private keys between OpenSSH, PEM and DER encoding, and OpenSSH, PKCS8 and Traditional OpenSSL format.

**Supported Formats:**

* OpenSSH
* PKCS8
* Traditional OpenSSL (trad-openssl)

**Supported Encodings:**

* PEM
* OpenSSH (PEM)
* DER

## Installation

```bash
pip install ssh_keyconv
```

This will install the ssh_keyconv module and the ssh-keyconv executable.

## Example usage

1. Generate a SSH keypair

```bash
ssh-keygen -t rsa -b 4096 -f newkey_rsa
```

2. Convert the private key to PKCS8 format

```bash
ssh-keyconv -i newkey_rsa -f openssh -e openssh -o newkey_rsa.pem -F pkcs8 -E pem
```

## Development

1. Clone the repo

```bash
git clone https://codeberg.org/lkm35t/ssh-keyconf
```

2. Set up a virtualenv

```bash
cd ssh-keyconv
make setup
```

3. Run tests

```bash
make test
```

4. Bump the version number in `ssh_keyconv/__init__.py:__version__`

5. Build a release

```bash
make clean build
```

6. Do a test publish

```bash
make publish-test
```

7. Verify the test publish

```bash
make verify-publish-test
```

8. Publish to PyPI

```bash
make publish
```

9. Verify the publish to PyPI

```bash
make test-publish
```
PanR 0.1.1
A Python tool for panresistome analysis
Requires Python: >=3.7

# PanR: Panresistome Analysis Tool

## Overview
PanR is a Python-based tool for analyzing panresistome data. It processes NCBI and Abricate summary files, merges the data, and generates visualizations such as lollipop plots, bar plots, and heatmaps. The tool is designed to help researchers analyze and visualize gene presence and prevalence across different geographic locations. It requires `ncbi_clean.csv` from [FetchM](https://github.com/Tasnimul-Arabi-Anik/FetchM) and summary files in `.tab` (preferred) or `.csv` format from [Abricate](https://github.com/tseemann/abricate). 

### Key Features:
- Merges and processes NCBI and Abricate data.
- Analyzes gene presence across samples.
- Generates visualizations for resistance gene distributions/prevalence.

## Installation

### Using `pip`
```bash
pip install panR
```

### Using `conda`
```bash
conda create -n panr_env python=3.8
conda activate panr_env
pip install git+https://github.com/Tasnimul-Arabi-Anik/PanR.git
```

### From GitHub (Manual Installation)
```bash
git clone https://github.com/Tasnimul-Arabi-Anik/PanR.git
cd PanR
pip install -r requirements.txt
```

## Usage

### Command-Line Arguments
```bash
panR --ncbi_dir <NCBI_DIRECTORY> --abricate-dir <ABRICATE_DIRECTORY> --output-dir <OUTPUT_DIRECTORY> --fig-format <FIGURE_FORMAT>
```

### Arguments
| Argument         | Description                                                |
|-----------------|------------------------------------------------------------|
| `--ncbi-dir`        | Path to `ncbi_clean.csv` file.                            |
| `--abricate-dir`| Directory containing Abricate summary `.tab` or `.csv` files. |
| `--output-dir`  | Directory to store merged results and visualizations.      |
| `--format`  | Output format for figures (`png`, `pdf`, `tiff`,`svg`).          |

### Example Run
```bash
panR --ncbi-dir ./data/ncbi_clean.csv --abricate-dir ./data/abricate --output-dir ./output --format png
```

## Outputs

- **Processed Data:** Saved in `output/` directory as `.csv`.
- **Visualizations:**
  - Heatmap of resistance genes across samples.
  ![figure1](figures/figure1.png)
  - Bar plot showing gene presence.
  ![figure3](figures/figure3.png)
  - lolipoplot showing gene counts
  ![figure2](figures/figure2.png)

## License
This tool is provided under the MIT License.

## Author
Tasnimul Arabi Anik
pkging 0.1.0
Build a single executable file of your Python program.
Requires Python: >=3.9
Keywords: python, packaging, tools

# pkging

![Tests](https://github.com/julianolf/pkging/actions/workflows/ci.yml/badge.svg?event=push)

Create a single executable file from Python programs.

Python supports the direct execution of Python code inside zip files. _pkging_ uses Python's built-in module [zipapp](https://docs.python.org/3/library/zipapp.html), bundling all dependencies inside the generated package, allowing easy distribution of software and dependency isolation.