semvec/pypi-packages huggingface dataset:
spikerplus 2.0.3
Build, train, optimize and generate hardware accelerators for Spiking Neural Networks usign VHDL
Requires Python: >=3.9

# Spiker: a framework for the generation of efficient Spiking Neural Networks FPGA accelerators for inference at the edge
This is the official repo of spiker, a comprehensive framework for generating efficient, low-power, and low-area customized Spiking Neural Networks (SNN) accelerators on FPGA for inference at the edge. spiker presents a library of highly efficient neuron architectures and a design framework, enabling the development of complex neural network accelerators with few lines of Python code. 


# Project structure
|	Component		|															Description																|
|:-----------------:|:---------------------------------------------------------------------------------------------------------------------------------:|
|	**spiker**		|	Python package to build, train, quantize and generate the VHDL description of hardware accelerators for Spiking Neural Networks	|
|	**Tutorials**	|									Examples on how to use the different components of spiker										|
|	**Doc**			|				Project documentation. It will be gradually filled with schematics, timing diagrams and similar						|


# Requirements

- numpy >= 1.20
- torch >= 1.12
- snntorch >= 0.9.1
- tabulate >= 0.9.0

# Installation

    git clone https://github.com/smilies-polito/Spiker.git
    cd Spiker
	pip install .

Or alternatively

	python setup.py install

# Citation
[Spiker: a framework for the generation of efficient Spiking Neural Networks FPGA accelerators for inference at the edge](https://arxiv.org/abs/2401.01141)

    @misc{carpegna\_spiker\_2024,
    	title = {Spiker+: a framework for the generation of efficient {Spiking} {Neural} {Networks} {FPGA} accelerators for inference at the edge},  
    	shorttitle = {Spiker+},  
    	url = {http://arxiv.org/abs/2401.01141},  
    	doi = {10.48550/arXiv.2401.01141},  
    	urldate = {2024-01-26},  
    	publisher = {arXiv},  
    	author = {Carpegna, Alessio and Savino, Alessandro and Di Carlo, Stefano},  
    	month = jan,  
    	year = {2024},  
    	keywords = {Computer Science - Neural and Evolutionary Computing, Computer Science - Artificial Intelligence, Computer Science - Hardware Architecture}   
    }

# Acknowledgements

[Neuropuls](https://neuropuls.eu/)

This project has received funding from the European Union’s Horizon Europe research and innovation programme under grant agreement No. 101070238. Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union. Neither the European Union nor the granting authority can be held responsible for them.

The code in spiker/vhdl/vhdltools was modified starting from [rftafas/hdltools](https://github.com/rftafas/hdltools).

I would like to thank Domenico Elia Sabella for their valuable assistance in revising and cleaning the final version of the code published on the open repository.
pipeline-ui 0.0.5
The best way to build AI pipelines
Requires Python: >=3.10

# PipelineUI
PipelineUI is a python package that allow you to create your own comfyui style backend for your ML code.

with pipelineUI we expose two new decorator that can be added to your python project to create graphical interface.

# how to install

`pip install pipeline-ui`

locally
`git clone`
`uv pip install -e .`

# Here is an example

create a example.py file

python
```
from pipeline_ui import PipelineUI

pui = PipelineUI()

@pui.node()
def add_numbers(a: int, b: int) -> int:
    return a + b

@pui.node()
def multiply(a: int, b: int) -> int:
    return a + b

@pui.workflow()
def math_workflow(a: int, b: int) -> int:
    c = add_numbers(a, b)
    d = multiply(c, d)
    return d
```
start with `python example.py` this start an web interface at localhost:8114
where you can see your code graphically

# commands
pui start pipeline_ui/examples/simple.py

pui publish pipeline_ui/examples/simple.py
baselog 2.1.0
helper for log initialization
Requires Python: >=3.10

# baselog

`baselog` is a Python module intended to simplify and standardize logging in our Python applications, particularly Dockerized applications. It is simply a thin wrapper around the stdlib [logging](https://docs.python.org/3/library/logging.html) module.

Many of our codebases are containerized and have the following operational requirements:
* Log messages get logged to the standard error (in agreement with the [12 factor](https://12factor.net/) design principles)
* If a `log_dir` path is supplied, a new log file is also created in that directory for every run of the app
* All uncaught exceptions are logged as described above
* Standard timezone-aware formats for log messages and timestamps

## Example

In the main file in an application, `BaseLog` is used to initialize both the console and file loggers.

```python
#!/usr/bin/env python3
from baselog import BaseLog

from .util import otherfunc


logger = BaseLog(
    __package__,
    log_dir="/logs",
    console_log_level="DEBUG",
    file_log_level="DEBUG",
)

def main():
    logger.info("starting a thing")
    otherfunc()

if __name__ == '__main__':
    main()
```

In other files of the project you just import the standard python logging module and get a logger.

```python
#!/usr/bin/env python3

import logging

logger = logging.getLogger(__name__)


def otherfunc():
    logger.warning("Log 'em'!")
```

A `sys.excepthook` is set by `BaseLog`, so in the case of an uncaught exception, the exception and traceback are logged to the console and log files:

```log
2023-04-11T20:06:59+0000 - logdemo - INFO - starting a thing
2023-04-11T20:06:59+0000 - logdemo.util - WARNING - Things may be happening
2023-04-11T20:06:59+0000 - logdemo.other.funcs - INFO - Things aren't happening yet
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - uncaught exception: RuntimeError; What the heck?!
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-000: Traceback (most recent call last):
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-001:   File "<frozen runpy>", line 198, in _run_module_as_main
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-002:   File "<frozen runpy>", line 88, in _run_code
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-003:   File "/app/logdemo/__main__.py", line 21, in <module>
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-004:     main()
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-005:   File "/app/logdemo/__main__.py", line 17, in main
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-006:     whatsit()
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-007:   File "/app/logdemo/other/funcs.py", line 10, in whatsit
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-008:     raise RuntimeError("What the heck?!")
2023-04-11T20:06:59+0000 - logdemo - CRITICAL - traceback-009: RuntimeError: What the heck?!
```
uastyle 0.2.1
Ukrainian colors for matplotlib
Requires Python: >=3.7

# UA colors for matplotlib

[![Pypi](https://img.shields.io/pypi/v/uastyle.svg)](https://pypi.org/project/uastyle/)
![Python 3.7+](https://img.shields.io/badge/python-3.7%2B-blue)
[![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)

`uastyle` - is a light Python package that provides blue-yellow styling for matplotlib.

## Install

Install `uastyle` using pip:

`pip install uastyle`

## How to use

### Explicit syntax

To use `uastyle`, import it and then call make_default_colors():

```
import uastyle
uastyle.make_default_colors()

colors = uastyle.colors
figsize = uastyle.M_width
```

### Simplified syntax

You can also import `apply_colors`, `colors`, and `M_width` directly:

```
from uastyle import apply_colors, colors, M_width
```

Importing `apply_colors` will apply changes to the default matplotlib colors.

If you want to avoid the "PylintW0611: unused-import" error, you can import from `apply_colors` directly:

```
from uastyle.apply_colors import colors, M_width
```
sms-service-aggregator 0.1.0
A SMS service aggregator supporting multiple providers
Requires Python: >=3.6

# SMS Service Aggregator

A Python library that provides a unified interface for multiple SMS service providers including Aliyun, Tencent Cloud, China Mobile, and generic HTTP APIs.

## Features

- Support for multiple SMS providers
- Template-based SMS sending
- Raw content SMS sending
- Easy to extend for new providers
- Unified error handling and response format

## Installation