semvec/pypi-packages huggingface dataset:
num2words-bydna 0.0.1
A small module for converting numbers to words
Requires Python: >=3.7

# Num2WordsMyDNA

This is a simple numbers to word package. You can use
[My GitHub Page](https://github.com/beastboixdna)
to ask your questions.

num2word_mydna is a Python package for converting numbers to word sequences using custom short abbreviations.

## Installation

To install num2words_mydna, simply use pip:

## Usage

To use Num2Word MyDNA, first import the `num2words_mydna` module:

Then, you can use the `num2words_mydna` function to convert a number to word.
PythonDebuggerTools 0.0.18
A collection of useful debugging tools
Requires Python: >=3.6

# PythonDebuggerTools

This is a collection of useful debugging tools to make your python development process faster.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install PythonDebuggerTools-0.0.16

```bash
pip install PythonDebuggerTools
```

## Usage
### Using the Debug.logger decorator

```py
from PythonDebuggerTools.logger import Debug

D = Debug()
D.DEBUG = True

@D.logger(important_params=['x', 'y'])
def add(x, y):
    return x + y
```

## Logger Key-word arguments
* **important_params**
  * a python list of paramaters to print in the standard output
* **output_file**
  * a string containing the name of the file to redirect debugging messages to


### Using the Log module
```py
from PythonDebuggerTools.logger import Log

info = Log()
info.DEBUG = True

f2_log = Log()
f2_log.DEBUG = False

def f1(a):
    # code that executes
    info.log("Debug statements for function f1 that are printed")
    #continue execution of code

def f2(x, y):
    # code that executes
    f2_log.log("Debug statements for function f2 that are not printed!")

```

## Contribution Guidelines
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## Github Repository
[PythonDebuggerTools Github Repository](https://github.com/Luna-Cake/Logger)
humidifier 0.0.2
Create human-friendly IDs from strings.
Keywords: ids,slugify

# humidifier

Create human-friendly IDs from strings.

![License](https://img.shields.io/github/license/fmatter/humidifier)
[![Tests](https://img.shields.io/github/actions/workflow/status/fmatter/humidifier/tests.yml?branch=main&label=tests)](https://github.com/fmatter/humidifier/actions/workflows/tests.yml)
[![Linting](https://img.shields.io/github/actions/workflow/status/fmatter/humidifier/lint.yml?branch=main&label=linting)](https://github.com/fmatter/humidifier/actions/workflows/lint.yml)
[![Codecov](https://img.shields.io/codecov/c/github/fmatter/humidifier)](https://app.codecov.io/gh/fmatter/humidifier/)
[![PyPI](https://img.shields.io/pypi/v/humidifier.svg)](https://pypi.org/project/humidifier)
![Versions](https://img.shields.io/pypi/pyversions/humidifier)

The typical use case for `humidifier` is that you have some string (a word, a name, a phrase...) that you want to turn into a human-friendly ID.
For example, your project has URLs containing IDs, and it would be nicer to have `/record/an-example` instead of `/record/21937218`.
Such IDs are easy to remember and can function as a preview for the database entry.
This can be achieved with the excellent [`python-slugify`](https://github.com/un33k/python-slugify), to which humidifier adds the option to generate unique IDs


## Usage
Using `humidifier` is rather simple:

```python
from humidifier import humidify

id_1 = humidify("dog", unique=True)  # 'dog'
id_2 = humidify("dog", unique=True)  # 'dog-1'
id_3 = humidify("dög", unique=True)  # 'dog-2'
id_4 = humidify("ʔɚ", unique=True)  # 'null'
id_5 = humidify("ʔɚ", unique=True)  # 'null-1'
```

If your strings come from different populations that you would like to keep distinct in the generated IDs, there is an optional `key` argument:

```python
from humidifier import humidify

id_1 = humidify("dog", key="animals", unique=True)  # 'dog'
id_2 = humidify("dog", key="quadripeds", unique=True)  # 'dog'
id_3 = humidify("dög", key="animals", unique=True)  # 'dog-1'
id_4 = humidify("dög", key="animals", unique=True)  # 'dog-2'
```

If you are working with an existing set of IDs:

```python
from humidifier import Humidifier
hum = Humidifier(["dog"])
hum.humidify("dog", unique=True)  # 'dog-1'
```

If you only want to generate a new ID for each distinct string:

```python
from humidifier import humidify

humidify("dög")  # 'dog'
humidify("dög")  # 'dog'
humidify("dog")  # 'dog-1'
```

You can also use any of the arguments described for [`python-slugify`](https://github.com/un33k/python-slugify).
The arguments `max_length` for truncating, `separator` for something other than `-` in between parts, and `replacements` may be of particular interest when generating IDs.