semvec/pypi-packages huggingface dataset:
mc-enchanter 0.0.5
A small python module that masters Minecraft enchanting mechanics.
Requires Python: >=3.6

# MC-Enchanter

## Description
**MC-Enchanter** is a simple python program that simulates the enchantment mechanics of the anvil in the popular game: [Minecraft](https://fr.wikipedia.org/wiki/Minecraft).
It's based on the Official Minecraft Wiki page: [*Anvil/Mechanics*](https://minecraft.gamepedia.com/Anvil/Mechanics).

## Motivation
Let's say that you wanted a powerfull axe with all of the following enchantements: Sharpness V, Efficiency V, Silk Touch and Unbreaking III. Suppose that you got all corresponding enchanted books and you applied them one after the other to the axe using an anvil. You'll end up with a total cost of **28 EXP**.
But if you combined Silk Touch I and Unbreaking III first, and then you applied the rest of books then it will cost you **25 EXP**. 
This motivated me to write this program that by giving it the enchanted books you have, and the desired enchanted item, it gives you the cheapest (possible) books combination.

## Features
- [x] Calculate the exact total experience cost of any enchantment.
- [x] Find the minimum experience cost for a specific enchantements combination using enchanted books only.
- [ ] Find the minimum experience cost for a specific enchantements combination using enchanted books and items.
- [ ] Support items durability.
- [ ] Build a nice gui.

## Instalation

After downloading Python 3.6+, use the following pip command:

```
pip install --upgrade mc-enchanter
```

## Example
Let's take the example used in [Motivation](#Motivation)
```python
from mc_enchanter import *

axe = EnchantableItem([], "axe")

unbreaking3 = EnchantedBook([ Enchantment('Unbreaking', 3) ])
sharpness5 = EnchantedBook([ Enchantment('Sharpness', 5) ])
efficiency5 = EnchantedBook([ Enchantment('Efficiency', 5) ])
silk_touch = EnchantedBook([ Enchantment('Silk Touch', 1) ])

enchantedBooks = [unbreaking3, sharpness5, efficiency5, silk_touch]
combination = BestBooksEnchantmentCombination(axe, enchantedBooks)

print(combination)
```
Output
```
[25, ((axe, Book(Sharpness V), 5), (axe, Book(Efficiency V), 6), (axe, Book(Book(Silk Touch I)+Book(Unbreaking III),3), 11))]
 ^ The    | ^_> Combine the axe    |  ^_> Combine the axe       |    ^_> 1- Combine Book(Silk Touch I) with Book(Unbreaking III) costs 3 EXP
 cheapest | with Book(Sharpness V) |  with Book(Efficiency V)   |     2- Combine axe with the resulting book: Book(Book(Silk Touch I)+Book(Unbreaking III),3)
   cost   |     costs 5 EXP        |      costs 6 EXP           |                            costs 11 EXP
```
stoltzmaniac 0.2.0
A lightweight library for basic machine learning tasks.
Requires Python: >=3.7,<4.0
Keywords: stoltzmaniac

# stoltzmaniac  

A Python package to solve simple data science problems. 

This is a rudimentary library for machine learning with 3 concepts in mind. This library should be:
  - easy-to-use
  - easy-to-read
  - easy-to-interpret

Optimization for efficiency of compute, latency, and memory will not be a priority.

The only external package we will use for modeling will be `numpy`. Others required are simply to get data into `numpy.ndarray` format.

This is my first package, so help out and don't hold back on putting in PR's. Thank you!

Installing:
```bash
pip install stoltzmaniac
```

----

Run tests  
`pytest`

Add packages (example with requests):

For development:
`poetry add -D requests`

For production:
`poetry add requests`

Build:
`poetry build`

Publish:
`poetry publish`
erdkeys 0.1.3
Tools for working with elrond pem files and json keystores
Requires Python: >=3.6

# erdkeys

This are Flying Stone's little tools for converting between [elrond](https://elrond.com) wallet pem files and json 
keystores. Please be aware that the private key is written in plaintext in the pem file. The json 
keystores are much safer to use.

Use at your own risk and remember: if you run code you haven't read and understood, you can't be 
sure that it is not sending me your keys ;-)

## installing

Before insptalling erdkeys, make sure that `pip3` in installed. If you already installed `erdpy`, you should already have `pip3`.

`$ pip3 install erdkeys`

This will also install a couple of dependencies: the extremely cool [cryptography](https://pypi.org/project/cryptography/)
library and a small module to deal with bech32 addresses. 

## usage

`$ pem2json.py pem_file password`

`$ json2pem.py json_file password` 

For instance, one of my [Battle of Nodes](https://battleofnodes.com) wallet keystore is `erd1g2ufua664sxjvxmw5hh72he3xy6w4gk9l8e4lvfjeyh8d0jk7gdsfrpdu0.json` and I need to convert it to pem format for use with [erdpy](https://github.com/ElrondNetwork/erdpy):

`json2pem.py erd1g2ufua664sxjvxmw5hh72he3xy6w4gk9l8e4lvfjeyh8d0jk7gdsfrpdu0.json mYpAsSwOrD`

will produce a file `erd1g2ufua664sxjvxmw5hh72he3xy6w4gk9l8e4lvfjeyh8d0jk7gdsfrpdu0.pem` in the same directory. You will get an error in case the keystore is corrupted or you entered the wrong password. 

When creating a keystore with pem2json, the password must satisfy the same requirements as the official [wallet](https://wallet.elrond.com).

## license

MIT
move-my-files 0.2.4
CLI tools to organize files on your computer
Requires Python: >=3.5, <4

# move-my-files

`mmf` is a cli tool for organising files on your computer. Tell it the file name patterns, where to move and matching files from a source directory are moved to target directory. Run it as one-off command or in watch mode to continously observe a source directory.

## Installation

Prerequisites:

- Python >=3.5
- `pip` package manager

Install `mmf` using:

```sh
# Install or upgrade mmf
pip install move-my-files -U
```

## Usage

Move files using either one time command or watch mode:

```sh
# Supply source and destination directory explicitly
mmf move --source ~/Documents --dest-dir ~/Documents/images --pattern .png

# Uses predefined configuration(provided in using add command)
mmf move --source ~/Documents

# Watch ~/Documents directory for moving files
mmf move --source ~/Documents --dest-dir ~/Documents/images --pattern .png --watch
mmf move --source ~/Documents --watch
```

Define your favorite configurations using `add` command. This command keeps track of your configurations so they are not required to be typed in future. Use `list` command to list configurations you've previosly added.

```sh
# Add configuration
mmf add --dest-dir ~/Documents/images --pattern .png
mmf add --dest-dir ~/Documents/pyfiles --pattern .py

# List configurations (previously added)
mmf list

# move without --dest-dir will use configurations
mmf move --source ~/Documents --watch
```

Available shortcuts for options:

- `--source`: `-s`
- `--dest-dir`: `-d`
- `--pattern`: `-p`
- `--watch`: `-w`

## Development

Fork and clone this repository to develop on latest master branch. General steps to execute python code form this repo:

```sh
# Create development environment
cd /move-my-files
virtualenv .env && source .env/bin/activate
python3 setup.py install

# Execute CLI (from code)
python3 .
python3 . list
```

Local testing with unit tests and CLI:

```sh
# Run available unit tests
python3 -m pytest tests -v

# Install CLI locally to test (basically testing setup.py)
pip install -e .
mmf
```

For Packaging and publishing see here:

- https://packaging.python.org/guides/distributing-packages-using-setuptools

## Contribute

If you have ideas to improve this tool, feel free to raise a new issue in the Issues section or open a PR :)
QSAR 0.0.2
Python library for QSAR model from Juvena Machine Learning Team.
Requires Python: >=3.6
Keywords: QSAR

QSAR Library
============

The 'QSAR' package provides a simple python interfact for using Juvena QSAR deep
learning model.

Links
~~~~~

    * QSAR @ PyPi_


Installation
~~~~~~~~~~~~

Install on Linux, MacOS
-----------------------
.. code:: bash
    python3 -m install QSAR

.. note:: Read the `User Guide`_ and `The Juvena QSAR Tutorial`_  to learn more 
          and to see the code examples on using the `QSAR` model as a library
          and as a command-line tool.

Update
~~~~~~
- June 18: True Positives and True Negatives from Thach presentation:
   - TP: FGF2, FGF8, FGF9, FGF18, PTHrP, Ihh, Shh, Wnt1, Wnt3a, Wnt5a, Wnt5b, DLL-1
   - TN: TGFβ, TGF-β2, TGF-β3, BMP2, BMP4, BMP7, GDF5, Wnt4, Wnt8, Wnt9a, VEGF, IGF1, Frzb-1, triiodothyronine, thyroxine



License
~~~~~~~

This library package is distributed under the GNU Lesser General Public License 
v3 or later `license`.

.. _pip: https://pip.pypa.io
.. _pypi: https://pypi.org/project/QSAR
BoJo 0.1.2
Command-line tool for bullet journaling

# bojo

`bojo` is a command-line bullet journal. If you're new to bullet journals, check out [/r/bulletjournal](https://www.reddit.com/r/bulletjournal/) or the bullet journal [website](https://bulletjournal.com/).

![demo](demo.gif)

## Getting Started

Install the tool using

```
pip install bojo
```

It should be relatively self-explanatory to get started with. Here are the possible commands:

```
> bojo --help

Usage: bojo [OPTIONS] COMMAND [ARGS]...

  A command-line bullet journal.

Options:
  --help  Show this message and exit.

Commands:
  add       Adds a new item
  complete  Mark an item as complete
  delete    Delete an item forever
  info      Provides information about annotation
  list      Lists relevant items
```

So, to add a new entry, just do:

```
> bojo add

Description: Make a cool bullet journal command line tool
State: x
Signifier [none]: !
Parent [none]:
Time [none]: tomorrow at 6pm
! x Make a cool bullet journal command line tool Thursday, June 18, 2020 at 6:00 PM
Do you want to add this item? [y/N]: y
Added item
```

To see our existing entries, do:

```
> bojo list

Last 1 item(s):
1 ! x Make a cool bullet journal command line tool Thursday, June 18, 2020 at 6:00 PM

Upcoming 1 item(s):
1 ! x Make a cool bullet journal command line tool Thursday, June 18, 2020 at 6:00 PM
```

Once we've completed an entry, do:

```
> bojo mark complete 1

OR

> bojo mark x 1

1 ! x Make a cool bullet journal command line tool Thursday, June 18, 2020 at 6:00 PM
Marked item 1 as complete
```

## Notes

**Shouldn't "bullet journal" be abbreviated "bujo", not "bojo"?**

I mean, yeah, technically. It's faster to type "bojo" into the command line, though.

## Environment Variables

- `BOJO_ROOT` points to the root path for storing data. By default, this is `~/.bojo`
- `BOJO_VERBOSE` is an option which, when set, toggles verbose mode (not just symbols). This is good for when you're getting started.
- `BOJO_NUM_ITEMS` sets the number of items to list by default