semvec/pypi-packages huggingface dataset:
nn-plots 1.0.2
Neural Network Performance Analysis
Requires Python: >=3.10

# <img src='https://abrain.one/img/lemur-nn-icon-64x64.png' width='32px'/> Neural Network Performance Analysis

The original version of the NN Plots was created by <strong>Waleed Khalid</strong> at the Computer Vision Laboratory, University of Würzburg, Germany.

<img src='https://abrain.one/img/lemur-nn-plot-t.jpg' width='25%'/>

<h3>Overview 📖</h3>

<p>Automated conversion of <a href="https://github.com/ABrain-One/nn-dataset" target="_blank" rel="noopener noreferrer">LEMUR</a> data into Excel format with statistical visualizations. It is developed to support the <a href="https://github.com/ABrain-One/nn-dataset">NN Dataset</a> and <a href="https://github.com/ABrain-One/nn-gen">NN Gen</a> projects.</p>


## Installation of the Latest Version of the NN Dataset

```bash
pip uninstall nn-dataset -y
rm -rf db
pip install git+https://github.com/ABrain-One/nn-dataset --upgrade --force --extra-index-url https://download.pytorch.org/whl/cu124
```

#### The idea of Dr. Dmitry Ignatov
dragon-e 2.0.2
Encrypt like a dragon: new method for securing data
Requires Python: >=3.8

# Dragon-E
## What is it?
Dragon-E (or just Dragon) is a simple but powerful library to encode messages. It relies on the end-user having the decryption key.
## What does it look like?
Encoded messages will look something like this:
`154:221:169:238:253:184:108:204:179:230:206:254:185:220:241:251:179:135:226:169:116:183:139:180:240:245:178:192:254:170:236:195:237:189:148:168:241:166:218:242:86:200:197:139:189:250:243:106:188:232:168:238:189:236:174:150`
In this case, the original message was `Dragon Encryption is a lightweight, easy to use package.` and was encoded using the passkey `AV3ry57r0nGp4Ssw0Rd!?`.
## What makes it so amazing?
1. Unlike some other encryption methods, the encoded message's length is not dependent on the passkey's length. This makes it more difficult to guess the passcode.
2. Every part of the passkey is important, meaning that you can't solve it all at once.
3. The longer the message and passkey, the more difficult it is to decode.
4. As of its 2.0.0 update, Dragon offers <b>Image Encryption</b>! This essentially encrypts the message using `stealthencrypt` and then transfers it into an image.
    * The resulting image is of type `PIL.Image` and is always square.
## How can I download it?
`pip install dragon-e`

# EXAMPLE
## Encrypting
```py
import dragon_e as de

important_info = de.encrypt("Don't share this info with anybody!", "V3ry57r0ngS3cuR17yK3Y")
with open('secret_file.dragon', 'w') as f:
    f.write(important_info)
```
```py
import dragon_e as de

important_info = de.stealthencrypt("Don't share this info with anybody!", "V3ry57r0ngS3cuR17yK3Y")
# Stealth Encryption just removes the delimiters and can be decoded the exact same way as with delimiters.
with open('secret_file.dragon', 'w') as f:
    f.write(important_info)
```
```py
import dragon_e as de

im = de.imageencrypt("Don't share this info with anybody!", "V3ry57r0ngS3cuR17yK3Y")
im.show()
```
The above code would display this image: <img src="./test1.PNG"> which could be decrypted with `imagedecrypt`.
## Decrypting
```py
import dragon_e as de
f = open('secret_file.dragon', 'r')
super_secret = f.read()
f.close()
decrypted = de.decrypt(super_secret, "V3ry57r0ngS3cuR17yK3Y")
print("Decoded information: "+decrypted)
```
```py
import dragon_e as de
decrypted = de.imagedecrypt("path/to/image.png", "V3ry57r0ngS3cuR17yK3Y")
print("Decoded information: "+decrypted)
```
RemoteNowApiWrapper 0.0.12
Wrapper for the RemoteNowApi
Requires Python: >=3.11

# remoteNowApiWrapper
 
This is a generic implementation of the remoteNow-Client for TVs \
The primary usecase for this will be a home assistant integration

Special Thanks to: \
MrAsterisco: https://github.com/MrAsterisco/homebridge-hisense-tv \
Krazy998: https://github.com/Krazy998/mqtt-hisensetv
ezbroadcast 0.0.1
Its the brodcast feture from scratch in python bacicly
Requires Python: >=3.12

# Brodcast

## what is this
Do you know the scrach brodcast block, its that but in python

## documentation
<table>
<tr>
    <th> function </th>
    <th> action </th>
    <th> example </th>
</tr>
<tr>
    <th> @brodcast.on(name) </th>
    <th> Put this above the function you want to activate with brodcast
    replace the name variable with the name you want the variable to call said function </th>
    <th>

    @brodcast.on("test") 
        def check(): 
            print("this works")

    brodcast.cont("test") 
    
</tr>
<tr>
    <th> brodcast.cont(name) </th>
    <th> This command will activate all fuctions assigned to the name variable and continue withount waiting </th>
    <th>

    import time

    @brodcast.on("test") 
        def check(): 
            time.sleep(1)
            print("This is second")

    brodcast.cont("test") 
    print("This is first")

</tr>
<tr>
    <th> brodcast.wait(name) </th>
    <th> This command is like brodcast.con but will wait for all of the functions to finish before continueing </th>
    <th>

    import time

    @brodcast.on("test") 
    def check(): 
        time.sleep(1)
        print("This is first")

    brodcast.cont("test") 
    print("This is second")

</tr>

<tr>
    <th> brodcast.debug() </th>
    <th> This command is used for </th>
    <th>


    
    @brodcast.on("a")
    def my_func():
        print("this function exists")

    if "a" in brodcast.debug():
        print("you should see this")
        # this tag is on my_func
    
    if "b" in brodcast.debug():
        print("and not this")
        # this tag is on nothing

</tr>
</table>

## brodcast also supports threding aplications

    change = False

    @brodcast.on("test")
    def my_func():
        global change
        print("a")
        change = True
        while change:
            time.sleep(.1)
        print("c")

    @brodcast.on("test")
    def my_func2():
        global change
        while not change:
            time.sleep(.1)
        print("b")
        change = False
        

    brodcast.wait("test")  
    print()
    print("done")
    # outputs a, b, c, then done
netbox-plugin-themes 0.5.1
A Netbox plugin to customise the look of Netbox using CSS themes
Requires Python: >=3.9

# NetBox Themes Plugin

Plugin to inject custom CSS themes into NetBox.

Tested on Netbox >= 4.1.0.

> [!WARNING]  
> This is experimental so use at your own risk 🌞

# Installation

Install the plugin:

```
pip install netbox-plugin-themes
```

Add to Netbox configuration:

```
# configuration.py
PLUGINS = [
    'netbox_themes',
]
```

Run the migrations and generate static content:

```
manage.py migrate
manage.py collectstatic
```

Then restart the Netbox service.

# Create a theme!

This is a basic example to change to a monospace font:

![Create a theme](media/create-theme.png?raw=true "Create a theme")

Or take a look in the `samples` directory:

![Doom](media/doom.png?raw=true "Doom theme")

![Sunrise](media/sunrise.png?raw=true "Sunrise theme")

![Christmas](media/christmas.png?raw=true "Christmas theme")

![Greggs](media/greggs.png?raw=true "Greggs theme")

## Build instructions

```
python3 -m pip install --upgrade build
python3 -m build
```
cgroup-monitor 1.0.0
A simple library to monitor CPU and Memory usage only using cgroups. Mainly created to monitor the resources inside the container.
Keywords: cgroup, docker

# cgroup-monitor

[![PyPi](https://img.shields.io/pypi/v/cgroup-monitor.svg)](https://pypi.org/project/cgroup-monitor/)
[![Documentation Status](https://readthedocs.org/projects/cgroup-monitor/badge/?version=latest)](https://cgroup-monitor.readthedocs.io/en/latest/?badge=latest)
[![License](https://img.shields.io/github/license/veedata/cgroup-monitor)](https://github.com/veedata/cgroup-monitor/blob/main/LICENSE)
[![Downloads](https://pepy.tech/badge/cgroup-monitor)](https://pepy.tech/project/cgroup-monitor)

# Description
cgroup-monitor is a Python package that provides a simple interface to monitor cgroup metrics. It is designed to be used in a containerized environment to monitor the resource usage of the containers. It can be used to monitor the CPU, and memory, of the containers. 
> The current version is only compatible with cgroup v1 (Ubuntu 20.04 and lower)

# Installation
```bash
pip install cgroup-monitor
```

# Usage
```python
from cgroup_monitor import CgroupMonitor

monitor = CgroupMonitor()
monitor.start_monitor()
# run task here
cpu, mem = monitor.stop_monitor()

print(f"CPU Usage: {cpu}%, Memory Usage: {mem}%")
```

# Features
- Monitor CPU and Memory usage of the containers
- Simple interface to start and stop monitoring
- Lightweight and easy to use

# Documentation
The official documentation is hosted on Read the Docs: https://cgroup-monitor.readthedocs.io/en/latest/

# License
This project is licensed under the terms of the MIT license, see [LICENSE](./LICENSE).

# Contributing
Contributions are welcome, and they are greatly appreciated! Every little bit helps.
openengine 1.0.0
A backtesting and live trading engine library for Indian markets
Requires Python: >=3.8

# OpenEngine

OpenEngine is a Python library for backtesting and live trading in Indian markets. It features an event-driven architecture and integrates with the OpenAlgo PlaceOrder API for live execution.

## Features

- Event-driven backtesting engine
- Live trading support
- Integration with Yahoo Finance for historical data
- Moving average crossover strategy included as example
- Modular design for easy extension
- Support for Indian markets (NSE)

## Installation

Install from PyPI:

```bash
pip install openengine
```

For development installation:

```bash
git clone https://github.com/yourusername/openengine.git
cd openengine
pip install -e .
```

## Quick Start

```python
from openengine.data.yahoo_connector import YahooFinanceConnector
from openengine.strategies.sample_strategy import SampleStrategy
from openengine.engine.backtester import Backtester

# Initialize components
data_connector = YahooFinanceConnector()
data = data_connector.fetch_data("RELIANCE.NS", "2022-01-01", "2023-01-01")
strategy = SampleStrategy()

# Run backtest
backtester = Backtester(data, strategy, initial_capital=100000)
portfolio = backtester.run()
print(portfolio.tail())
```

## Usage

### Backtesting

Run the included example:

```bash
python -m openengine.main
```

### Live Trading

```python
from openengine.engine.live_trader import LiveTrader
from openengine.execution.broker_interface import BrokerInterface
from openengine.strategies.sample_strategy import SampleStrategy

# Initialize components
broker = BrokerInterface("http://your-broker-api", "your-api-key")
strategy = SampleStrategy()
trader = LiveTrader(strategy, broker)

# Process market data
trader.on_new_data({
    "symbol": "RELIANCE.NS",
    "price": 2500.0,
    "timestamp": "2025-02-06 09:15:00"
})
```

## Development

### Adding New Strategies

Create a new strategy by inheriting from `BaseStrategy`:

```python
from openengine.strategies.base_strategy import BaseStrategy

class MyStrategy(BaseStrategy):
    def generate_signals(self, data):
        # Your strategy logic here
        return signals
```

### Running Tests

```bash
python -m pytest tests/
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
cmeel-example 0.7.2
This is an example project, to show how to use cmeel
Requires Python: >=3.8

# Example project C++ for cmeel

[![PyPI version](https://badge.fury.io/py/cmeel-example.svg)](https://pypi.org/project/cmeel-example)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/cmake-wheel/cmeel-example/main.svg)](https://results.pre-commit.ci/latest/github/cmake-wheel/cmeel-example/main)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Test](https://github.com/cmake-wheel/cmeel-example/actions/workflows/test.yml/badge.svg)](https://github.com/cmake-wheel/cmeel-example/actions/workflows/test.yml)
[![Release](https://github.com/cmake-wheel/cmeel-example/actions/workflows/release.yml/badge.svg)](https://github.com/cmake-wheel/cmeel-example/actions/workflows/release.yml)

This is an example project, to show how to use [cmeel](https://github.com/cmake-wheel/cmeel), and to provide tests for it

## Test this

### Installation

Binary wheels are published on PyPI for many Linux and mac OS flavors and architectures, so you'll probably be able to
install from binaries with `python -m pip install cmeel-example`
(don't forget to use an up-to-date `pip` with `python -m pip install -U pip`).

If pip can't find binaries for your platform, it will download the `.tar.gz` source and build it for you.

If you really want to explicitely build it yourself:
`python -m pip install git+https://github.com/cmake-wheel/cmeel-example.git`

### Usage

From shell:
```
cmeel-add 3 4
```

From python:
```python
import cmeel_example
cmeel_example.cmeel_add(3, 4)
```
timesTable 2.0.0
prints an N x N multiplication table
Requires Python: <4,>=3.6

# times-table

A utility to print a nicely formatted n-by-n times-table for any base from two to sixty-two.

```
optional arguments:
  --base N, -b N  The base of the number system. Base must be in range [2, 62]. (default=10).
  --size N, -n N  The largest number in the table. Must be greater than 1. (default=13).
  --primes        only print out the multiplication table for prime numbers
  --limit MAX     Limit printing the table to numbers of length MAX-digits or less
```
## Installing `times-table`

```
    python3 -m pip install timesTable
```
If you already have `times-table` installed, upgrade to newer versions like this:

```
    python3 -m pip install timesTable --upgrade
```
It's recommended to install into a local `venv`, or if installing systemwide
as the super-user to make a `venv` in `/usr/local/venv`, and install it there.
For some helpful hints about how to do this see the 
[`addendum`](https://github.com/jrowellfx/lsseq?tab=readme-ov-file#addendum---more-on-installing-command-line-tools)
in the [`lsseq`](https://github.com/jrowellfx/lsseq) repo.

### Testing `times-table`

Running `times-table` on the command line should show you this.

```
$ times-table
  * |   2    3    4    5    6    7    8    9   10   11   12   13
----+-------------------------------------------------------------
  2 |   4*   6    8   10   12   14   16   18   20   22   24   26
  3 |   6    9*  12   15   18   21   24   27   30   33   36   39
  4 |   8   12   16*  20   24   28   32   36   40   44   48   52
  5 |  10   15   20   25*  30   35   40   45   50   55   60   65
  6 |  12   18   24   30   36*  42   48   54   60   66   72   78
  7 |  14   21   28   35   42   49*  56   63   70   77   84   91
  8 |  16   24   32   40   48   56   64*  72   80   88   96  104
  9 |  18   27   36   45   54   63   72   81*  90   99  108  117
 10 |  20   30   40   50   60   70   80   90  100* 110  120  130
 11 |  22   33   44   55   66   77   88   99  110  121* 132  143
 12 |  24   36   48   60   72   84   96  108  120  132  144* 156
 13 |  26   39   52   65   78   91  104  117  130  143  156  169*
```

Now you can play with the various options. Enjoy!