semvec/pypi-packages huggingface dataset:
linearized-musicxml 1.0.0
MusicXML linearization for img2seq model training
Requires Python: >=3.8

# Linearized MusicXML (LMX)

A python package for linearizing and de-linearizing MusicXML into a sequential format so that it can be used for training img2seq machine learning models.

Install via:

```
pip3 install linearized-musicxml
```

Use from the command line:

```bash
# MusicXML -> LMX (accepts both XML and MXL)
python3 -m lmx linearize example.musicxml # produces example.lmx
python3 -m lmx linearize example.mxl # produces example.lmx
cat example.musicxml | python3 -m lmx linearize - # prints to stdout (only uncompressed XML input)

# LMX -> MusicXML (only uncompressed XML output available)
python3 -m lmx delinearize example.lmx # produces example.musicxml
cat example.lmx | python3 -m lmx delinearize - # prints to stdout
```

## Acknowledgement

This package uses code first developed for an ICDAR 2024 paper by Mayer et al. See the acknowledgement there: https://github.com/ufal/olimpic-icdar24
forthic-lang 4.0.0
A stack-based language for concisely building tweakable apps

# Forthic

Forthic is a stack-based language for making apps tweakable.

## Documentation

For a brief overview of Forthic, see [OVERVIEW.md](https://github.com/linkedin/forthic/blob/main/docs/OVERVIEW.md).
The [SYNTAX.md](https://github.com/linkedin/forthic/blob/main/docs/SYNTAX.md) file shows what the language looks like, including a brief overview of some of the standard global Forthic words.
The [IDIOMS.md](https://github.com/linkedin/forthic/blob/main/docs/IDIOMS.md) file gives pointers on how to use Forthic the way it was designed to be used.
The [ARCHITECTURE.md](https://github.com/linkedin/forthic/blob/main/docs/ARCHITECTURE.md) file shows how Forthic interpreters can work within apps.

Forthic modules are documented in the [modules](https://github.com/linkedin/forthic/tree/main/forthic-py/docs) directory.

### YouTube

There are several YouTube videos for learning Forthic

-   [Coding Forthic with Rino](https://www.youtube.com/@codingforthic) goes over some of the example applications
-   [Learning Forthic](https://www.youtube.com/playlist?list=PLSnCkfp4FIBQJEM9SNeGLjt_VrPrHMzQF) teaches Forthic using [Forthix Jira Plugins](https://marketplace.atlassian.com/vendors/1225195/forthix-llc) and Jupyter notebooks.

### Articles

-   [Forthic How To](https://forthix.com/category/how-to/)
-   [LinkedIn Article on how to use the Jira module](https://www.linkedin.com/pulse/hello-forthic-abdul-sheik)
-   [Categorical Coding](https://forthix.com/category/categorical-coding/)
ninam 1.0.1
A steganography tool for hiding a secret message in text using different unicode spaces
Requires Python: >=3.8

# Ninam

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ninam)
![PyPI - Downloads](https://img.shields.io/pypi/dm/ninam)


Ninam is a steganography tool to encode or decode a payload in a text file by replacing white space character.
I created this programme because I remembered when I was younger that I liked to send people secret messages by hiding them in a text message.

## How it works ? 

All spaces in the text are recovered and replaced by other [unicode space characters](https://en.wikipedia.org/wiki/Whitespace_character). If there is not enough space available, additional spaces will be added at the end. 
You can use 1-bit, 2-bit or 4-bit encoding. This means using 2, 4 or 16 white spaces. The larger the bitsize, the larger your payload can be, but at the risk of having slightly suspicious white spaces.


## Installation 

There is no dependencies and should work with all version of python>3.x

```bash
pip install ninam
```

## Usage 

``` bash  
    # By default, it used 2 bits
    ninam encode -i input.txt -p iloveyou > output.txt
    ninam decode -i output.txt 

    # Alternative bitsize
    ninam encode -b 4 -i input.txt -p iloveyou > output.txt
    ninam decode -b 4 -i output.txt  
    
```

## From git 

```
git clone git@github.com:dridk/ninam.git
python -m ninam 
```
simpleset 0.4.1
Better Than Enums
Requires Python: <4.0,>=3.7

\[ [Documentation](https://simpleset.readthedocs.io/en/latest/) | [Cheatsheet](https://simpleset.readthedocs.io/en/latest/cheatsheet/) | [Changelog](https://github.com/odigity/simpleset/blob/master/CHANGELOG.md) \]

### Disclaimer!

tl;dr — Expect breaking changes in the future, and pin the version to protect yourself.

This package is very new and has only been used by me as far as I know.

When others start using it in different contexts, providing useful feedback on the quality of the API, and guiding its evolution to a mature 1.0 release, I will then offer API stability guarantees and adhere to SemVer.

In the meantime, I see no harm in using it in production given how simple it is.  However, _**please make sure to pin your package dependency to an exact version**_ so your code doesn't break if and when I decide to change something.

### Synopsis

I dislike Python [Enums](https://docs.python.org/3/library/enum.html).  They behave strangely and are difficult to build on top of or extend.  This package provides a Python class named `Constant` which facilitates the creation and usage of immutable enumerated value sets.  This plain old Python class is both simpler to understand and more powerful/flexible then native enums.

Even a Python beginner should be able to understand *most* of the source code.  The exceptions are discussed in the [docs](https://simpleset.readthedocs.io/en/latest/internals/).

### Preview

```python
from simpleset import Constant

# simplest form

Color = Constant.define_set( "Color", "RED", "GREEN", "BLUE" )

Color.RED == "RED"          # -> True  (equality to strings)
Color.RED.cname             # -> "RED"
Color.all                   # -> [ Color.RED, Color.GREEN, Color.BLUE ]
Color.max_length            # -> 5  (useful for a VARCHAR db column)

# more complex

Color = Constant.define_set(
    "Color",
    RED   = dict( hex="ff0000", like=True  ),
    GREEN = dict( hex="00ff00", like=True  ),
    BLUE  = dict( hex="0000ff", like=False ),
)

Color.RED.hex               # -> "ff0000"
Color.select( like=True  )  # -> [ Color.RED, Color.GREEN ]
Color.get(    like=False )  # -> Color.BLUE
```

[Learn more.](https://simpleset.readthedocs.io/en/latest/)

---

Historical Note:  This package was originally named [py-objects](https://pypi.org/projects/py-objects/).