semvec/pypi-packages huggingface dataset:
python-iq-sim 0.0.4
Python Library for starting and managing simulations in the Intelligent Quads Cloud
Keywords: python,sim,cloud,mavlink,ardupilot,px4

# Python-IQ-Sim

This repo is a python library for controlling starting stopping and managing simulations running in the Intelligent Quads Cloud.

## Installation

```bash
pip install python-iq-sim
```

## Generate Docs

```bash
pydoc-markdown -I iq_sim -m iq_sim --render-toc > docs/iq_sim.md
```

## Documentation Available 

https://intelligent-quads.gitbook.io/python-iq-sim-documentation/

## Example

```python
import iq_sim
import os
from pymavlink import mavutil


token = os.getenv("IQ_SIM_TOKEN")

api = iq_sim.iq_sim(token)
sim_id = api.start_sim()
api.wait_for_sim_ready(sim_id)

connection_info = api.get_connection(sim_id)
print(connection_info)
conn_str = f"tcp:{connection_info['ip']}:{connection_info['port']}"

mavlink_conn = mavutil.mavlink_connection(conn_str)
mavlink_conn.wait_heartbeat()
print("Heartbeat from system (system %u component %u)" % (mavlink_conn.target_system, mavlink_conn.target_system))

# add pymavlink script here

api.stop_sim(sim_id)
```

## Customize Simulation Configuration

Simulation Configuration is in the form of:
```json
{
    "sim_config": [
        {
            "sim_type": "default-sitl",
            "vehicle_type": "ArduCopter",
            "vehicle_model": "X",
            "instances": "1",
            "flight_controls": "Ardupilot",
            "fc_version": "Copter-4.2.3",
            "latlonaltheading": [
                "-35.363261",
                "149.16523",
                "584",
                "353"
            ]
        }
    ]
}
```
the default config is available by accessing `iq_sim().sim_config`. This can be modified and passed to the `start_sim` method as shown below:


```python
import iq_sim
import os
from pymavlink import mavutil


token = os.getenv("IQ_SIM_TOKEN")

api = iq_sim.iq_sim(token)
config = api.sim_config
config["sim_config"][0]["instances"] = "2"
sim_id = api.start_sim(config)
api.wait_for_sim_ready(sim_id)

connection_info = api.get_connection(sim_id)
print(connection_info)
conn_str = f"tcp:{connection_info['ip']}:{connection_info['port']}"

mavlink_conn = mavutil.mavlink_connection(conn_str)
mavlink_conn.wait_heartbeat()
print("Heartbeat from system (system %u component %u)" % (mavlink_conn.target_system, mavlink_conn.target_system))

# add pymavlink script here

api.stop_sim(sim_id)

```
TellrawCommandGenarator 0.0.1
Tellraw command generator for Minecraft


This module is a tool for making tellraw commands easier to create.

Usage:

Even though its meant to be simple, there are still steps to creating your command.

To create a line, you have to make an instance of the "Line" class,

and all of the attributes are written in between the parentheses of the class.

There is a specific order of the attributes: Text, Color, Underline, Italic, Bold, Obfuscated, and Strikethrough.

Example: line1 = line("Hello World","orange",True,True,True,False,False)

After you are done creating your lines, put them in a list and in the parentheses of the "GenerateCommand",

The result will be returned.

Example:

line1 = line("Hello","red",True,True,True,False,False)

line2 = line(" World!","blue",True,True,True,False,False)

lines = [line1, line2]

command = GenerateCommand(lines)

print(command)

Notes:

In-game, every line will be combined into 1 line with no spaces,

so dont forget to put in spaces before each line and Backslash + N for line breaks.

Also, replace the <targets> text in the result with your actual targets.

Update notes:

0.0.1 First upload
jsoneng 1.0.8
A package for a python JSON database CRUD engine
Requires Python: >=3.6

# JSON Engine

This is the lite version of the JSON Engine

please refer to https://pypi.org/project/jsoneng/ for the python package

and please refer to https://github.com/youhengzhou/jsoneng for the repo

# Download Package

`py -m pip install jsoneng -U`

## In Your Python Files

`import jsonengine`

# Commands

## Create command:

`eng.create(dictionary, path)`
This will create a JSON dictionary in the path

## Retrieve command:

`eng.retrieve(path)`
This will retrieve the JSON dictionary in the path

## Update command:

`eng.update(dictionary, path)`
This will update a JSON dictionary in the path

Update in this case means replacing the dictionary in its entirety with a new one

## Update (with key value) command:

`eng.update_kv(key, value, path)`
This will update a key value pair in the JSON dictionary in the path

Update in this case means replacing the dictionary with the key value pair

## Patch command:

`eng.patch(dictionary, path)`
This will patch a JSON dictionary in the path

Patch in this case means keeping the JSON dictionary in the path and appending to the dictionary

## Patch (with key value) command:

`eng.patch_kv(dictionary, path)`
This will patch a key value pair in the JSON dictionary in the path

Patch in this case means keeping the dictionary and appending the new key value pair

## Delete command:

`eng.delete(path)`

This will delete the JSON dictionary in the path
skinseg 0.0.1
Contains tools for segmentation of skin lesion images. A prebuilt unsupervised Segmentation model and various helper functions to increase the efficacy of segmentation. Includes tools to visualise, compare, experiment with different image configurations and segmentation types. Tools can be used in cascade to the mask generator or independently. Feel free to play around with.
Requires Python: >=3.7

# Unsup-Segmentation

This repository contains code that was a part of the project "SEGMENTATION AND CLASSIFICATION OF SKIN LESION IMAGES USING DEEP LEARNING BASED TECHNIQUES", published as part of my final year project. This was an experiment to create an unsupervised segmentation pipeline that can create segmentation masks of any given skin lesion image from the ISIC datasets. Although this was predominantly tested on the 2016 and 2017 datasets, this can be extended to latter datasets as well. These are the results tested on the 2016 dataset.

![image](https://github.com/DevBhuyan/Unsup-Segmentation/assets/55915667/7f81729b-cd6f-45c8-a387-ce8cd9846ea4)

The complete pipeline will require you to run the "mask_generator.py" file first, which should save the unfiltered mask images into an 'UNFILTERED/' directory inside your 'MASKS/' directory. After that, you can run either of "color_clean.py" or "texture.py" (first one being a simpler cleaning approach while the second one being a slightly more complicated but accurate approach), this will create the final masks for you. At any point of time you can run the "metrics.py" file to check the performance of the model. You can run all of these algorithms sequentially or in parellel. Graph execution won't be an issue as they read each image and process it in real time. For example, if you have been running `mask_generator` for a few minutes and have a few images in the `UNFILTERED/` directory, you can run `texture` which will start working on the unfiltered images in real-time. `tqdm` will consider the existing number of files and start accordingly. Simiarly, you can run `metrics` at any point to check the performance on the masks generated so far.

You can download the original ISIC 2016 dataset from https://challenge.isic-archive.com/data/. Or you can try this on your own dataset. To run `metrics`, you'll need to have reference masks against which the generated masks will be compared.

You can play with "permute_channels.py" to get an idea of how the different channels interact when combined. 

"mask_overlay.py" will help you draw the mask outlines on the original images so that you can have a better idea of how the algorithm is performing.

Feel free to play around with the code. Also make sure to modify the directory locations as required.