semvec/pypi-packages huggingface dataset:
micro-logger 0.1.4
A JSON logger made for microservices

# micro-logger

A JSON logger made for microservices

# Usage

```python
import micro_logger

# This overrides the root logger as well

logger = micro_logger.getLogger("my-service")

logger.info("sure", extra={"a": 1})
```

# Testing

```python
import micro_logger_unittest

import micro_logger

# Use this class as a base

class TestUnitTest(micro_logger_unittest.TestCase):

    # Override for all tests

    @unittest.mock.patch("micro_logger.getLogger", micro_logger_unittest.MockLogger)
    def setUp(self):

        self.logger = micro_logger.getLogger("unit")

    # Any test can check for logging

    def test_assertLogged(self):

        self.logger.info("sure", extra={"a": 1})

        self.assertLogged(self.logger, "info", "sure", extra={"a": 1})
```
ncar-isd-s3 1.1.2
NCAR ISD S3 object storage utility
Requires Python: >=3.1

# isd-s3
NCAR ISD S3 Object Storage utility.

A command line tool to manage data access to the NCAR S3 Object Storage
system.  Developed by the Information Systems Division (ISD), a division 
within the Computational and Information Systems Laboratory (CISL) at the
National Center for Atmospheric Research (NCAR).

Source Code: [https://github.com/NCAR/isd-s3](https://github.com/NCAR/isd-s3)

### Installation
Install with `pip install ncar-isd-s3`

You can then import the module `isd_s3`.  For example:
```
from isd_s3 import isd_s3
session = isd_s3.Session()
session.list_buckets()
```
mkdocs-inline-select-svg-plugin 0.1.0
A MkDocs plugin that inlines SVG images matching a pattern into the output without inlining Materials theme icons.
Requires Python: >=3.8
Keywords: mkdocs,mkdocs-plugin,plugin,svg

# mkdocs-plugin-inline-select-svg

A [MkDocs plugin] that inlines SVG images matching a pattern into the output without inlining Materials theme icons.

This operates post HTML generation looking for `img` elements like

```html
<img src="foo.svg" ...>
```

When the *src* is a path-local URL with a path component that ends
with `.svg` and it matches the configured pattern then the file is
read from the local file system and inlined in place.

Alt text is ignored in favour of any SVG `<title>` element.

If the SVG contains any elements marked with `class="do-not-inline"`,
they will not be included in the inlined content.
This is useful when your SVG images contain `<style>` elements that
you do not want to bleed into the containing scope, and your Mkdocs
configuration includes extra CSS stylesheets that suffice.

## Usage

To download and install this module, run:

```sh
pip install mkdocs-inline-select-svg-plugin
```

Enable the plugin in your *mkdocs.yml* by adding `inline-select-svg` as a list item under the *plugins* section.  Since that section will almost certainly include *search* you might end up with something like this:

```yaml
plugins:
    - search
    - inline-select-svg
```

If you want to filter which SVGs to inline, by path, you can specify a regular expression using the *pattern* config option thus:

```yaml
plugins:
    - search
    - inline-select-svg:
        pattern: "[.]inline[.]svg$"
```

With that configuration, `<img src="../foo.inline.svg">` would be
inlined but `<img src="../foo.svg">` would not.

[MkDocs plugin]: https://www.mkdocs.org/dev-guide/plugins/
apoplan 0.0.3a33
Bauplan CLI
Requires Python: >=3.8,<4.0

# Bauplan CLI

## Requirements

- [direnv](https://direnv.net/)
- [nix](https://nixos.org)
- [devenv](https://devenv.sh/)

## Package publication

### Nathan version

Currently wheel is only supported on OSX with arm64

First compile dependency binaries (the actual CLI)

```bash
$ python build.py
...
```

To build the poetry package:

```bash
$ poetry build
...
```

To publish, first bump the version, then run `publish`

```bash
$ python build.py && poetry -vvv publish -u __token__ -p pypi-blahblahblah --build
...
```

### Big version

Create a `.env` file on the root of the `cli` project (I have a `.env-amarone-dev` file) with:

```bash
POETRY_PYPI_TOKEN_PYPI={{ op://BauplanLabs/pypi - github-all-events-publish-bauplan/credential }}
```

Where:

- `BauplanLabs` is my Vault name
- `pypi - github-all-events-publish-bauplan` is the Key of my `API Credential` item
- `credential` is the field containing the auth token.

To build the poetry package:

```bash
$ make build
```

To publish, first bump the version, then run `publish`

```bash
$ make publish
...
```
unicornhatsimulator 1.0.4
Pimoroni UnicornHAT simulator (pHAT, HAT and HAT HD)
Requires Python: >=3.8

# Unicorn HAT (HD) simulator 

###### v1.0.4

Unicorn HAT (HD) simulator - Originally by Jannis Hermanns &lt;jannis@gmail.com>, modified by Mark Pitman &lt;mark.pitman@gmail.com> and adjusted by me (Matt Brash &lt;matt@brash.ca>)

Simulates a Unicorn HAT HD (and should work for the 8x8 HAT and the 8x4 PHAT as well) using pygame.
The version you see here includes the following edits:
- Added `set_all(r, g, b)` to set the entire buffer to one colour
- Modified the `clear()` function to act like the real HAT (clears the buffer, not the screen)
- Added `get_pixel(x, y)` to return a tuple of the r, g, b values of a pixel
- Added `get_pixels()` which returns the entire buffer as an array of arrays of arrays ([y][x][r, g, b])
- Modified `set_pixel()` to accept a colour string, for example `set_pixel(x, y, "red")` see [set_pixel.md](set_pixel.md)
- Added the non-standard `set_pixel_size(value)` which is only for the simulator to increase or decrease the dot size
- Fixed the rotation code to rotate counter-clockwise correctly
- Commented the code thoroughly
- Size the initial window based on the size of the HAT and pixel size

## Usage

If you want your code to run on your computer as well as your Pi, you could do something like this:

1. `pip install unicornhatsimulator` (or `pip2` or `pip3` depending on your setup)
2. Adjust your `import unicornhathd` statement as follows:

```python
'''
Note: The alias "as unicorn" can be whatever you want (or nothing at all).
For example: as u
'''
try:
    import unicornhathd as unicorn
    print("unicorn hat hd detected")
except ImportError:
    from unicornhatsimulator import unicornhathd as unicorn
```

You can choose from `import unicornhathd` (16x16), `import unicornhat` (8x8) and `import unicornphat` (8x4). 

## Demo

(Note that this gif has a low framerate, the simulator runs nice and smooth in real life)

![Demo](https://cl.ly/2s070z1k0L3J/Screen%20Recording%202017-06-26%20at%2011.12%20PM.gif)

## TODO

- [ ] find a python person to show me how this would be done properly. For example - leaving the window open at the end.
- [x] fix/check rotation
- [x] add a proper LED glow effect so it looks more like a real unicorn HAT
- [x] publish via pip ([now online at pypi](https://pypi.org/project/unicornhatsimulator/))
- [x] add `get_pixel(x, y)` and `get_pixels`
- [x] add non-standard `set_pixel_size(p)` to increase or decrease dot sizes

---

#### Disclaimer

I am _not_ a `pygame` programmer. I'm barely a `python` programmer. I found the original code for the simulator and tried to modify it to match the current state of the [Pimoroni UnicornhatHD](https://github.com/pimoroni/unicorn-hat-hd) library. This was in order to have my students be able to work on their projects in [Replit](https://replit.com) when they don't have access to their physical raspberry pi's from class.

Feel free to leave suggestions (issues, bugs) but do not expect a timely response.


~ M. Brash
unit-run 0.0.7
Easy to inspect, store and reperform unit running process.
Requires Python: >=3.7

# unit-run
## Description

This package is used to simply run a unit *(only supports the ``Callable`` object currently)* in Python **without any extra running code**. And it can also save/load all your input parameters as/from a simple json file, so it is easy to run a target unit with auto-input parameters group by give it just a group name.

## Documentation
See [document](https://lingfei-he.github.io/unit-run/doc/_build/html/intro.html)


## To do
- Support for any code segment and the classes from popular package like `numpy.ndarray`.
- Support for complete storage for `Unit` (including the target unit object).
- Maybe create a new buldled file extension named `.unit` to pack all the data files into a single file and provide graphic user interface to get access to it.
- Support for multiple languages.
SegRunLib 0.0.6
This is the module for medical images segmentation
Requires Python: >=3.6
Keywords: ml nn cnn

### **SegRunLib** ###
This is simple library for vessel segmentation

----------

## How to install ##
To install, you can use the command:

    pip install SegRunLib

Or download the repository from [GitHub](https://github.com/NotYourLady/SegRunLib)

----------

## Using Example ##
```
import SegRunLib

settings = {
    "in_path_nifty" : "MRA_Image.nii.gz",
    "out_path_nifty" : "MRA_Image_segmentation.nii.gz",
    "device" : "cuda"
}

SegRunLib.run(settings)
```

msst project  
- easy to use for everyone
- no prerequirenments
  
----------

![alt text](https://github.com/NotYourLady/SegRunLib/blob/main/source/Unet3d_16ch_results.jpg)

## From the developer ##
> Hello. Have a good day!
python-bebop 1.3.2
bebop runtime bindings for Python
Requires Python: >=3.8

# Python bebop

Bebop is a schema-based binary serialization technology, similar to Protocol Buffers or MessagePack. In particular, Bebop tries to be a good fit for client–server or distributed web apps that need something faster, more concise, and more type-safe than JSON or MessagePack, while also avoiding some of the complexity of Protocol Buffers, FlatBuffers and the like.
automata-py 0.1a2
A simple Python (3.10+) implementation aimed at simulating some cellular automata, primarily those focused on by Stephan Wolfram in his book "A New Kind of Science".
Requires Python: >=3.10,<4

## Automata

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/orome/automata-py.git/main/?urlpath=lab/tree/demo.ipynb)
[![Testing](https://github.com/orome/automata-py/actions/workflows/test-and-deploy.yml/badge.svg?branch=main)](https://github.com/orome/automata-py/actions/workflows/test-and-deploy.yml)
[![PyPi](https://img.shields.io/pypi/v/automata-py.svg)](https://pypi.python.org/pypi/automata-py)
[![PyPi Status](https://img.shields.io/pypi/status/automata-py.svg)](https://pypi.python.org/pypi/automata-py)
[![Supported Python](https://img.shields.io/pypi/pyversions/automata-py.svg)](https://pypi.python.org/pypi/automata-py)

A simple Python (3.10+) implementation aimed at simulating some cellular automata,
primarily those focused on by Stephan Wolfram, 
as I read along in [A New Kind of Science](https://www.wolframscience.com/nks/p315--the-intrinsic-generation-of-randomness/),
perpetually very much under construction. 

To play with the latest semi-stable version, 
[launch the demo notebook](https://mybinder.org/v2/gh/orome/automata-py.git/main/?urlpath=lab/tree/demo.ipynb) 
in Binder.

![Example display](https://raw.githubusercontent.com/orome/automata-py/main/docs/readme_eg.png)

A [related project](https://github.com/orome/turing-py) covers some basics of Turing Machines.
RUpassport 0.1.5
Recognizes data from Russian passports and returns them
Requires Python: >=3.6
Keywords: ru rus RU RUS passport RUpassport recognition

# RUpassport #

## What is this? ##
Library to recognizes data from Russian passports and returns them

## Quick Guide ##
    pip install RUpassport
####
    from RUpassport import Pasport
    
    p = Pasport()
    pasport_info = p.recognize_pasport("img.png", "file", "123")
    print(pasport_info)
pyconversor 0.0.1
pyconversor is a lib developed with the aim of unifying all the conversion tools a dev might need during development in one place.

# pyconversor

Pypi link.

## Motivation

pyconversor is a lib developed with the aim of unifying all the conversion tools a dev might need during development in one place.

## Instructions

1. Install:

    ``` shell
        pip install pyconversor
    ```

2. Convert:

    **Example:**

    ``` python
    from pycorvert import pyconversor

    test = {
    
        "People":{
            "Name":"Alan",
            "Address":{
                "Street": "Of dumbs",
                "Number":0
            }
        }
    }
    string = pyconversor.convert_dict_to_xml(dictionary=test, raw_string=False)

    print(string)

    ```

## features and plans

- [x] Convert a dictionary to a XML (on a raw string or not)
- [ ] Convert a xml to a dictionary/.

## To upload your own project to pypi

Follow [this site](https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-your-project-to-pypi)