semvec/pypi-packages huggingface dataset:
tiny-dag 0.0.18
Minimal DAG implementation with Python
Requires Python: >=3.6

# Tiny DAG

A small library to orchestrate and visualize function calls using graph structure.

The library contains bare-bones implementation of computation (directed, acyclic) graph. User provides a graph structure
(nodes) and input data for the graph. The graph executes every node in the graph and returns output of every node as the 
result. The library supports multiple outputs per node, caching of the node results, and parallel execution of the nodes.

# Requirements

This is plain Python, no external hard requirements.

- Python >= 3.6
- graphviz (optional, needed for rendering graphs)

# Installation

Install graphviz (optional)
```
sudo apt-get install graphviz
```

Install tiny-dag
```
pip3 install tiny-dag
```

# Usage

Here are the rules:
- Node functions need to return dict (or None) with keys matching node output definition.
- Output of the node is referenced in the graph structure by node_name/output_name.
- User needs to provide missing information, as dict, when calculate method is called.  

And that's it. Otherwise, you are free to write any kind of functions and orchestrate calling of those functions by 
defining nodes that form the graph.

Usage example:
```
from tinydag.graph import Graph
from tinydag.node import Node

def add(a, b): return {"output": a + b}
def mul(a, b): return {"output": a * b}
def div(a, b): return {"output": a / b}
def add_subtract(a, b): return {"add_output": a + b, "subtract_output": a - b}

nodes = [
    Node(["add1/output", "x"], add, "add2", ["output"]),
    Node(["add1/output", "add2/output"], mul, "mul", ["output"]),
    Node(["x", "y"], add, "add1", ["output"]),
    Node(["x", "z"], add_subtract, "add_subtract", ["add_output", "subtract_output"]),
    Node(["mul/output", "add_subtract/add_output"], div, "div", ["output"]),
]

graph = Graph(nodes)
graph.render()

data = {"x": 5, "y": 3, "z": 3}
results = graph.calculate(data)
print(f"Result: {results}")
```

The results is dict of node outputs, in this case:

{'add1/output': 8, 
'add_subtract/add_output': 8, 
'add_subtract/subtract_output': 2, 
'add2/output': 13, 
'mul/output': 104, 
'div/output': 13.0}

render method produces following figure:
<p align="center">
<img src="sample_graph.jpg" width="800px" />
</p>

For a bit more complicated and practical usage, see how the library can be used to orchestrate and visualize data
processing pipelines: src/samples/sample_credit_risk_prediction.py.
silcar-it-tools 0.2.2
Basic IT tools used to solve common problems in the Central African Republic.
Requires Python: >=3.8

# IT Tools

Basic command-line tools used to solve common problems in the Central African Republic.

### exe-check

Quickly determine if EXE or other similar file has been "packed" with extra data;
i.e. it has been corrupted by a virus.



### get-usb-files

Recover "hidden" files on USB drive that are nested away in a series of folders
whose names consiste of a single, non-printable character. On Windows 10 these
folders are invisible to the user, and even when visible (Win11 and non-Windows
systems) they are nearly impossible to find without special knowledge or tools.
This is caused by the
["USB Driver.exe" virus](https://n8marti.gitlab.io/blog/post/2023-04-08-usbdriver-virus/).
myrt-desk-api 1.0.7
Library for controlling smart bulbs that are controlled by the DoIT protocol
Requires Python: >=3.7

# MyrtDesk API [![PyPI version](https://badge.fury.io/py/myrt-desk-api.svg)](https://pypi.org/project/myrt-desk-api/)

Library for controlling smart table functions with my own [firmware](https://github.com/mishamyrt/myrt_desk_firmware).

* **Fully asynchronous**
* Automatic detection
* Cool CLI tool

## API Example
This code will wait for the lights to turn off, then flash the backlight controller and then turn on the rainbow effect:

```py
from asyncio import run
from myrt_desk_api import MyrtDesk, Effect

async def main():
    desk_host = await discover()
    desk = MyrtDesk(desk_host)
    await desk.backlight.set_power(False)
    with open("./firmware.hex", mode="rb") as file:
        await desk.backlight.update_firmware(file.read())
    await desk.backlight.set_effect(Effect.RAINBOW)

if __name__ == '__main__':
    run(main())
```
accessi 0.0.8
Library for Siemens Access-i MR Scanner Interface to integrate and control the MR Scanner.
Requires Python: >=3.8

# Siemens Access-i Interface library
Library for Siemens Access-i MR Scanner Interface to integrate and control the MR Scanner. Based on Version 1.1.2 for NX (Access-i Developer Guide)

## Install
This is the easiest way to use the install the library, if you do not need to modify it.
```
pip install accessi
```

## Siemens Documentation
The library is based on this document:
[Access-i Dev Guide NX V1.1.2](documentation/Access-i_Dev_Guide_NX_V1.1.2.pdf)

## Usage guide
A sample test suite (tests.py) has been created which demonstrates basic Access-i usage.  
The tests.py requires Access-i simulator to be running on the background, on the same local computer.  
The tests.py demonstrates most of the implemented methods, as well as receiving images over websocket.  

### Usage examples
Here are some projects which have used this library:
- [Martin Reinok Thesis Software GitHub](https://github.com/martinreinok/master-thesis/tree/master/tracking-software)

## Access-i Licence for real MR at TechMed (Also works with simulator)
```
name="UTwente", 
start_date="20231102", 
warn_date="20251002",
expire_date="20251102", 
system_id="152379",
hash="uTwo2ohlQvMNHhfrzceCRzfRSLYDAw7zqojGjlP%2BCEmqPq1IxUoyx5hOGYbiO%2FEIyiaA4oFHFB2fwTctDbRWew%3D%3D",
informal_name="This name shows up on MR computer"
```
### Connection and IP Addresses
The Access-i in TechMed is running on this IP address:
```
10.89.184.9
Access-i Version: v1
```

Simulator IP:
```
127.0.0.1
Access-i Version: v2
```

In order to connect, the client must have the following networking settings:
```
Client IP: 192.168.182.20 (Maybe something else works too, have not tried)
Subnet: 255.255.255.0
Gateway: 192.168.182.1
DNS1: 192.168.182.1
```
### Multiple network adapters on the same computer
To be able to use both, Access-i and WAN (external interent) at the same time, some configurations are necessary. These are only compatible with Windows for now.

Find out what is the interface number, which is connected to Access-i:
```
route print
```

Using the interface number, create a route:
```
route add 10.89.184.0 mask 255.255.255.0 192.168.182.20 if 8 -p
```
Here __if 8__ is the interface number in this particular case, __-p__ means persistant so it will stay after reboot.

## Collaborating
The majority of Access-i functionality is not yet implemented here, if you need more functionality, any additions are accepted.
Network_Builder 0.0.1
Infrastructure as code network builder
Requires Python: >=3.10

# Network-Builder

## Device config json example:
```json
{
  "devices": [
    {
      "name": "Device_Name_1",
      "ip": "192.168.1.1",
      "port": 22,
      "type": "cisco_ios"
    },
    {
      "name": "Device_Name_2",
      "ip": "10.10.0.23",
      "port": 22,
      "type": "cisco_ios"
    }
  ]
}
```

## Task list json example:
``` json
{
    "tasks": [
        {
            "taskname": "Task Name 1",
            "taskdescription": "Task without argument",
            "target": "Device_Name_1",
            "command": "command_of_your_choice",
            "arguments": []
        },
        {
            "taskname": "Task Name 2",
            "taskdescription": "Task with argument",
            "target": "Device_Name_2",
            "command": "command_of_your_choice_with_argument",
            "arguments": [
                "argument_1",
                "argument_2"
            ]
        }
    ]
}
```