semvec/pypi-packages huggingface dataset:
MAxPy 0.1.2
Multi-layer Approximate Computing Python Framework
Requires Python: >=3.9

# MAxPy Multi-layer Approximate Computing Python Framework

**MAxPy** is a framework aimed for simulation and exploration of Approximate Computing techniques in VLSI designs. It is Ptyhon-based, free and *open-source*.

Check out our <a href="https://maxpy-project.github.io/MAxPy" target="_blank">documentation</a>!

MAxPy is part of the <a href="https://github.com/MAxPy-Project" target="_blank">MAxPy Project</a>.

## Installation
```sh
pip install MAxPy
```

## Examples
### Basic flow
#### RTL-level
```python
from MAxPy import maxpy
from testbench import testbench_run
circuit = maxpy.AxCircuit(top_name="adder4")
circuit.set_testbench_script(testbench_run)
circuit.rtl2py(target="exact")
```
#### Gate-level
```python
from MAxPy import maxpy
from testbench import testbench_run
circuit = maxpy.AxCircuit(top_name="adder4")
circuit.set_testbench_script(testbench_run)
circuit.set_synth_tool("yosys")
circuit.rtl2py(target="exact_yosys")
```
### Parameter exploration
```python
from MAxPy import maxpy
from testbench import testbench_run
circuit = maxpy.AxCircuit(top_name="adder4")
circuit.set_testbench_script(testbench_run)
circuit.set_group("study_no_1")
circuit.set_synth_tool(None)
circuit.set_results_filename("output.csv")
circuit.parameters = {
"[[PARAM_ADDER01]]": ["copyA","copyB", "eta1", "loa", "trunc0", "trunc1"],
"[[PARAM_K]]": ["0", "1", "2", "3"],
}
circuit.rtl2py_param_loop(base="rtl_param")
```
### Probabilist pruning
```python
from MAxPy import maxpy
from MAxPy import probprun
from testbench import testbench_run
circuit = maxpy.AxCircuit(top_name="adder4")
circuit.set_testbench_script(testbench_run)
circuit.set_synth_tool("yosys")
pareto_circuits = circuit.get_pareto_front("area", "mre")
probprun.probprun_loop(circuit, pareto_circuits)
```
SubLyric 1.0
Converts from SRT to LRC and vice versa.
Requires Python: >=3.6

This library is used to convert SRT files to LRC files and vice versa.

How to import:
from SubLyric import Converter

####
Available Functions:
`Converter.srt_to_lrc(srt_file_path, lrc_file_path)`

This function converts srt files to lrc.
input file/path is srt_file. output path/file is lrc_file.
SRT files use 3 digits for milliseconds while LRC files use 2 digits.
Therefore, all the timings will be the off by 0.001 to 0.005 seconds. 
(Normally it'd be 0.001 to 0.009, But there's a rounding function that helped with making it more accurate.)
This timing inaccurance should not be significant nor cause problems in captions/subtitles.


`Converter.lrc_to_srt(lrc_file_path, srt_file_path)`

This function converts lrc files to srt.
input file/path is lrc_file. output path/file is srt_file.
LRC files use 2 digits for milliseconds while SRT files use 3 digits. 
Therefore, all the timings will be the off by 0.001 to 0.009 seconds.
This timing inaccurance should not be significant nor cause problems in captions/subtitles.
Also, LRC files use minutes, seconds, and milliseconds only. Unlike SRT files that use hours, minutes, seconds, and milliseconds.
Motmauto 0.2.0
Refer to Readme
Requires Python: >=3.9

All the code for my master's thesis exists here. The presentation and videos for each of the different behaviors have also been uploaded.

Everything is organized around a project class and a parameter dictionary.

The project class handles all the data and model tracking for individual use cases. The parameter dictionary is coupled with the project class to implement all the different parameter changes for the models one wants. All this will be updated as the project continues. 


Currently working is:
-Autoencoder Reconstruction
-Autoencoder Preprocessing
-Autoencoder Training

Next steps are:
-Feature Extraction (Somehow couple this with an excel sheet?)
	-Parameter changes (filtering, etc...)

**
Currently working on this. It should work by having some modular function which just computes features.

-Train Embedding
	-Compute features for all datasets (done)
	-Persistent variable for tracking minmaxdata (done (changed to just saving it in the parameters))
(I'm imagining a func which looks something like train_embedding(project), which computes all the nescessary features)
train_embedding(project) 
	-Compute all features 
		-Find all proc_mice file, load it, for each:
			-compute features
			-update minmaxdata
			-update length cell array which is somehow coupled to the proc_mice_file (maybe use file registry for this?) (Done, used file registry for this)
			-save the data

			
			**
			Working Here!
		-Training subsampling procedure such that I grab only certain subsets of files
		-Normalize using minmaxdata
		-Compute Distance Matrix
		-Run tsne
		-Train Test Split
		-Train MLP to reembed
	mkdir in data folder for the project called Embeddingdata
	Embeddingdata
		-minmaxdata
		-MLP
		-Distance Matrix
		-Train Test Split
		-Features for Distance Matrix
return 0

**

-Embedding (Decision between autoencoder, tsne, or umap would be nice, for now we can just go with tsne)
-Pick a reembeding method (everything will be defaulted to what I used for my masters thesis)
-Embed all sleap files and make movies
 -Movie handling will be a big undertaking. How do we want to handle tracking the corresponding mp4's... Currently we are relying on the mp4 output filenames for tracking, that should continue to work. 
-Integration with fiber photometry
-Plotting functionality
-TACI integration
common-interfaces-intellisense 0.1.0
Get intellisense for ROS 2 interfaces
Requires Python: >=3.10

# common-interfaces-intellisense
Get intellisense for ROS 2 messages. Services are not supported. 
This is a only intended to be used for intellisense purposes.
Useful if developing on another system than where ROS 2 is available (Docker for example).
Code within this package is NOT intended to be ran.

## Installation
```bash
pip install common-interfaces-intellisense
```

## Usage
```python
from geometry_msgs.msg import Quaternion
from std_msgs.msg import String

# will now get intellisense
msg = Quaternion()

# or
msg = String(data="my string")
```

Here is an example of a generated class:

[`sensor_msgs/msg/CameraInfo.py`](/src/sensor_msgs/msg/CameraInfo.py)

```python
# flake8: noqa
from common_interfaces.base_types import *
from std_msgs.msg import Header
from . import RegionOfInterest

from typing import Any


class CameraInfo:
    """
    https://github.com/ros2/common_interfaces/blob/humble/sensor_msgs/msg/CameraInfo.msg

    Args:
        header: No information
        height: No information
        width: No information
        distortion_model: No information
        d: No information
        k: 9 elements
        r: 9 elements
        p: 12 elements
        binning_x: No information
        binning_y: No information
        roi: No information
    """
    def __init__(
        self,
        header: Header | Any = None,
        height: uint32 | int = None,
        width: uint32 | int = None,
        distortion_model: string | str = None,
        d: list[float64] | list[float] = None,
        k: list[float64] | list[float] = None,
        r: list[float64] | list[float] = None,
        p: list[float64] | list[float] = None,
        binning_x: uint32 | int = None,
        binning_y: uint32 | int = None,
        roi: RegionOfInterest | Any = None,
    ):
        self.header: Header | Any
        self.height: uint32 | int
        self.width: uint32 | int
        self.distortion_model: string | str
        self.d: list[float64] | list[float]
        self.k: list[float64] | list[float]
        self.r: list[float64] | list[float]
        self.p: list[float64] | list[float]
        self.binning_x: uint32 | int
        self.binning_y: uint32 | int
        self.roi: RegionOfInterest | Any

```

## Build
```python
from common_interfaces.build import BuildInterfaces

BuildInterfaces().build()
```