semvec/pypi-packages huggingface dataset:
mamon-tools 0.0.8
Common tools and utilities


# Mamon Tools

A set of tools and utilities for Mamon11 Python Development

## Installation
```sh
pip install mamon-tools
```

## Usage
To use any of these modules, just import from `mamontools`.

### Database
This module makes it easy to connect to our PostgreSQL databases. To use it, you have to add a `.env` file in the root of your project specifying the following environment variables:
```.env
DB_HOST=
DB_PORT=
DB_USER=
DB_PASSWORD=
```

Example usage:
```python
from mamontools import Database, dotenv

# Load environment variables
dotenv()

# Connect to clients database
db = Database('clients')
cursor = db.cursor

cursor.execute('SELECT * from clients')
result = cursor.fetchall()
print(result)

# Disconnect
db.disconnect()
```
fuzzy-magic 0.1.2
A Fuzzy Logic library to create Mamdani Fuzzy Systems the easiest way possible
Requires Python: >=3.6

# FuzzyMagic

The purpose of this library is to create in the easiest way possible Mamdani Fuzzy Systems. In order to do that, you just need: 

- A file in JSON format that contains each fuzzy set you want to create. The format must be like this: 
```json
{"LinguisticVariable1":{
        "terms": ["you", "are", "awesome"], //mandatory
        "type": "Triangular", //mandatory
        "universe_of_discourse": [0,10] //optional
        }
}
```` 
- A TXT file that contains the rules in Simpful format (although you can create this manually)

Then, you just do this...
```python
    from fuzzy_magic.fuzzy import FuzzyMagic
    FM = FuzzyMagic('path/to/fuzzyset/json', 'path/to/rules/txt')
    FuzzySystem = FM.do_magic()
```

and the magic is done!
voxtool 0.0.2
VoxTool: A tool for labeling intracranial electrodes on CT images

# VoxTool 2.0


## Setup

To install VoxTool, simply do:

```
pip install voxtool
```

We recommend using voxtool within a virtual environment. If you have anaconda installed, you can do:

  ```
  conda create -n vt
  ```

This creates an environment named `vt` in which to run voxTool. You can then install VoxTool within that environment by doing:

```
conda activate vt
pip install voxtool
```

## Running

Inside the environment where VoxTool is installed, type in the terminal:

```
voxtool
``` 

This will bring up the main VoxTool window.

## Usage
0. Load a CT file, adjusting the threshold as necessary. To adjust the
   threshold, change the number in the bar at the top of the window
   marked ```CT Threshold```, then press the ```Update``` button next to it.
1. If continuing a previous localization: load the existing coordinates
   from a JSON coordinate file using the ```Load Coordinates``` button.
2. Press ```Define leads``` to set the names, shapes, types, and microcontacts
   for each implanted lead. Shapes are rows x columns.
3. Select the lead you wish to localize in the dropdown menu labeled ```Label```
   in the upper left corner
4. Click on the CT to highlight the next contact on that lead, then press
   ```Submit``` to mark its location
   - Alternatively, press the ```Seeding``` button to turn on seeding. VoxTool
     will attempt to extrapolate the locations of the remaing contacts
     as you select them, incrementing the contact number. Be sure to double-check that
     the results make sense, as occasionally two contacts
     will be given the same location
   - Alternatively, add the ends of a strip or depth
     or the corners of the grid with the ```Submit``` button, then press
     the ```Interpolate``` button. VoxTool will attempt to fill in the lead.
     It may not be completely successful. Pressing ```Interpolate``` again
     may interpolate additional contacts.
5. Press ```Add Micro-Contacts``` to add micro-contacts to any macro/micro leads.
6. Press the ```Save as``` button to save the list of localized contacts.
   If the checkbox labelled ```Include Bipolar Pairs``` is checked, locations
   will also be saved for the midpoint of each pair of neighboring contacts.



## Keyboard Shortcuts:

Button | Key Sequence
------ |  ------------
Load Scan | Ctrl-O
Define Leads | Ctrl-D
Save As | Ctrl-S
Submit (contact panel) | S
Submit (lead definition window) | S
Delete (contact panel)| Delete
Delete (lead definition window)| Delete
Confirm (lead definition window) | Enter

## Other Notes
* The list of contact names is sorted by lead name, and within each 
lead by contact number. The ```Interpolate``` button does not always assign
contact numbers in the expected order, so be sure to double-check 
that the numbers it has assigned are the ones that you want after using 
it.
markdownizer 0.0.1
Generate docs with ease.
Requires Python: >=3.10

# Markdownizer

<p align="center">
    <em>Generate docs with ease.</em>
</p>

[![build](https://github.com/phil65/markdownizer/workflows/Build/badge.svg)](https://github.com/phil65/markdownizer/actions)
[![codecov](https://codecov.io/gh/phil65/markdownizer/branch/master/graph/badge.svg)](https://codecov.io/gh/phil65/markdownizer)
[![PyPI version](https://badge.fury.io/py/markdownizer.svg)](https://badge.fury.io/py/markdownizer)

---

**Documentation**: <a href="https://phil65.github.io/markdownizer/" target="_blank">https://phil65.github.io/markdownizer/</a>

**Source Code**: <a href="https://github.com/phil65/markdownizer" target="_blank">https://github.com/phil65/markdownizer</a>

---

## Development

### Setup environment

We use [Hatch](https://hatch.pypa.io/latest/install/) to manage the development environment and production build. Ensure it's installed on your system.

### Run unit tests

You can run all the tests with:

```bash
hatch run test
```

### Format the code

Execute the following command to apply linting and check typing:

```bash
hatch run lint
```

### Publish a new version

You can bump the version, create a commit and associated tag with one command:

```bash
hatch version patch
```

```bash
hatch version minor
```

```bash
hatch version major
```

Your default Git text editor will open so you can add information about the release.

When you push the tag on GitHub, the workflow will automatically publish it on PyPi and a GitHub release will be created as draft.

## Serve the documentation

You can serve the Mkdocs documentation with:

```bash
hatch run docs-serve
```

It'll automatically watch for changes in your code.

## License

This project is licensed under the terms of the MIT license.