semvec/pypi-packages huggingface dataset:
itech_serial 0.1.4
Control ITECH laboratory equipment using a serial port
Keywords: itech, it6800, it6811, it8500, it8511

# ITECH serial library for Python

Control ITECH test equipment using a proprietary 26-byte UART protocol.

You'll need to [make your own adapter](https://github.com/blinkinlabs/itech_usb_serial#itech-usb-to-serial-adapter)
to connect your test equipment to your computer, or presumably buy an
isolated one.

Note: If your test equipment has a USB port, use that instead! The -A and -B
variants of some ITECH product lines have an optional USB port, which is
is supported by standard USBTMC libraries such as pyvisa. This library
is intended for devices that only implement a proprietary control protocol
over a TTL serial port.

## Usage

First, install the library from pypi:

    pip install itech_serial

Then, assuming you have an IT8511 load, and it is connected to your computer
using a USB-to-serial converter that was identified as /dev/ttyUSB0, you can
open a connection to it like this:

    from itech_serial import IT8500
    load = IT8500('/dev/ttyUSB0')

During connection, the library will check that the device identify matches a
known string. If you have different equipment  that speaks the same protocol
(such as a BK Precision load), please create an issue on GitHub with the
device details and the reported string.

Once the connection is made, you first need to enable remote control to allow
the device to be controlled over serial:

    load.control_set_remote()

Next, you can set the device to (for example) a 0.5A constant current load:

    load.mode_set('cc')
    load.constant_current_set(0.5)
    load.enable()

You can then read back the measured voltage and current that the load sees:

    print(load.measure)

When you are done, be sure to turn the load off, and (optionally) set the
device control back to local to allow the front panel buttons to work again:

    load.disable()
    load.control_set_local()

## Identifying a specific USB device

If you know what USB to serial converter is connected to your instrument, you
can use the find_usb() function to locate it by VID, PID, and optionally
serial number:

    from itech_serial import find_usb
    load = IT8500(find_usb(vid=0x10c4, pid=0xea60, serial_number='00F84E81')[0])

This is especially helpful for situations where you have multiple instruments
connected to a single computer, and need a reliable way to connect to the
correct one.
rotarysaw 666.39.2077.10
Rotary Saw
Keywords: python, turrican, rotary saw, tirronen, rotarysaw

# Turrican Rotary Saw

![](https://turrican.uraanikaivos.com/rotarysawturrican.png)

Turrican turns into a impervious silver rotary saw in combat. Rotary Saw is my personal hack and quick scripts collection 
for whatever I try next.
gsc-rank-tracker 0.1.1
A basic rank tracker using Plotly and Google Search Console API.
Requires Python: >=3.6

# Rank Tracker

A basic rank tracker using Plotly connected to Google Search Console API.

## Installation

```sh
pip install rank_tracker
```

## Usage

```sh
rank_tracker
```

## Configuration

- Place your Google Search Console credentials JSON file in a folder named `secret` in the same directory as your script.
- Edit the `SITE_URL` variable in the script to match the URL of the site you're analyzing.
- Modify the `QUERIES` list with the search queries you're interested in.

## License

MIT License. See the LICENSE file for details.
rank-tracker 0.1.0
A basic rank tracker using Plotly and Google Search Console API.
Requires Python: >=3.6

# Rank Tracker

A basic rank tracker using Plotly connected to Google Search Console API.

## Installation

```sh
pip install rank_tracker
```

## Usage

```sh
rank_tracker
```

## Configuration

- Place your Google Search Console credentials JSON file in a folder named `secret` in the same directory as your script.
- Edit the `SITE_URL` variable in the script to match the URL of the site you're analyzing.
- Modify the `QUERIES` list with the search queries you're interested in.

## License

MIT License. See the LICENSE file for details.
fuzzy-redirect-mapper 0.1.0
A tool to speed up redirect mapping using fuzzy matching.
Requires Python: >=3.6

# Fuzzy Redirect Mapper

The Fuzzy Multi-format Redirect Builder Python script is a time-saving tool to help speed up redirect mapping. Every SEO knows that redirect mapping can be a tedious and very time-consuming task.

This python script helps you to speed up the redirect mapping process, saving yourself, your team, and your clients time and money.

## Installation

```sh
pip install fuzzy_redirect_mapper
```

## Usage

```python
from fuzzy_redirect_mapper import compare_urls_in_csv

file_name = "urls-input.csv"
column1 = "source"
column2 = "destination"
result_df = compare_urls_in_csv(file_name, column1, column2)
```

## License

MIT License. See the LICENSE file for details.
bare-estate 0.6
Manage your dotfiles seamlessly
Requires Python: >=3.7

# Bare Estate

## Table of Contents

- [About](#about)
- [Install](#install)

## About

Have you ever needed to install a brand new Linux distro or BSD system? Any
experient user has done this at least a couple times, and certainly has a
dotfiles repository somewhere. But how would you transfer your dotfiles? Maybe
with symbolic links, copying files from a cloned repository, flash drive or
perhaps a combination of those.

With Bare Estate you don't need a convoluted strategy for managing your
dotfiles. You can create a bare repository that will store your repository's
data. Manage your dotfiles as if they were on a regular repo. Even files from
your home directory, without actually turning your home into a git repository
itself.

And the best part is the application handles the abstraction for you,
so you can use it in the same you use git!

## Install

To install this package from the PyPI, you can use the command:

```sh
pip install -U bare-estate
```
bringUpSetup 1.0.2
This Package installs all the required packages for BringUp Automation Tool
Requires Python: >=3.8

# BringUpAutomation


This Repo is to automate the Bring up Sequence for various Platforms

Platforms include: 
- Leda 
- Pandia
- Future Platforms*

Pre Requisites:
- Bender Build Prior to the Bring Up process i.e. Nano FTAB, Nano SA, FSB FTAB, FSB SA
- Confirm the Train (for example LuckFennel for Pandia Bring up) for the PR Restore
- CFE bin files

Each Platform has different stages/tests which as a Platform Software Engineer we might want to test:

- Artifact Downloads for various (SA and FTAB for Nano/FSB) Bender Builds: We might be needing to download the bootloader scripts i.e. loading_config.ax file which is present inside package.tgz for Standalone Builds.
- Install Per Resquisites for Bring up such as Home Diagnostics
- Application Processor Restore: 
  - with Baseband Firmware
  - without Baseband Firmware
- CFE Test 
- Baseband Firmware Test
DigitalWallet 0.0.3
DigitalWallet is an async service that counts your currencies.
Requires Python: <3.12,>=3.8

## Digital Wallet

### Setup

```
git clone https://github.com/heliosgrounder/DigitalWallet.git
cd DigitalWallet
python -m venv venv
```

* Windows (PowerShell):
```
.\venv\Scripts\Activate.ps1
```

* Unix:
```
./venv/bin/activate
```

```
pip install -r requirements.txt
```

### Run

You can choose all available currencies in [this](https://www.cbr-xml-daily.ru/daily_json.js).

```
cd digitalwallet
```

```
python -m main --period 10 --rub 10 --debug y
```

```
python -m main --rub 100 --eur 300 --usd 200
```

```
python -m main --aud 200 --rub 0
```

### Using

You can go to `localhost:8000/docs` and use FastApi interface.
ArtexPing 0.0.1
A python internet status checking library
Requires Python: >=3.6

# Internet active checkking Project

This project leverages `requests` module to check internet connectivity. It's designed for simplicity and ease of use, allowing you to check internet connection active status.

## Features

- **Check internet**: Check if your device have a proper working internet connection or not.

## Prerequisites

- `requests`

## Setup

1. **Install dependencies**:
    ```sh
    pip install requests
    ```

## Usage

To use the functionality, import the `checkConnection` function from `ArtexPing`.

```python

from ArtexPing import InternetStatus

a = InternetStatus(output_file_path="output.txt")
a.checkConnection()

```

## Continuous Usage

If you want to check internet connection active status continuously, it is recommended to use threading. This will prevent the function from blocking the execution of further code until it is stopped.

Example with Threading
```python
import threading
import time
from ArtexPing import InternetStatus

a = InternetStatus(output_file_path="output.txt", continous=True)
ping_thread = threading.thread(target=a.checkStatus())

ping_thread.start()
time.sleep(10)
a.quit()
thread.join()
```

**This project is managed by Artex AI. Soon an improved and stable version will roll out**