semvec/pypi-packages huggingface dataset:
vorlang 0.0.6
The VOR Programming Language.
Requires Python: >=3.6

# VOR
[![CodeQL](https://github.com/VOR-Lang/vor/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/VOR-Lang/vor/actions/workflows/github-code-scanning/codeql)

[![wakatime](https://wakatime.com/badge/github/VOR-Lang/vor.svg)](https://wakatime.com/badge/github/VOR-Lang/vor)

VOR Programming Language: VHD (Very High Definition) Omnidirectional Range Programming Language

(This basically means this is a general purpose programming language)

## Table of Contents
- [VOR](#vor)
  - [Features](#features)
  - [Standard Libraries](#standard-libraries)

## Features

1. ***Importing Python Modules:*** VOR allows you to create modules in python which you can import into your script!
2. ***Custom Functions:*** VOR has built-in `debug()` and other functions to allow less code for you to write.

## Standard Libraries

- [system](https://github.com/Vor-Lang/system-lib)
SmartWaveAPI 2.1.3
A python API for the SmartWave interface.
Requires Python: >=3.8

# SmartWaveAPI
A python API for the SmartWave interface.

## Installation
- This package requires python version 3.
- To install this package, run the following command:
```bash
pip install SmartWaveAPI
```

## Usage
It is recommended to use the `with..as` pattern to implicitly call cleanup functions 
when resources of the SmartWave device are no longer needed.
### Basic I2C script
```python
from SmartWaveAPI import SmartWave

with SmartWave().connect() as sw:
    with sw.createI2CConfig() as i2c:
        # write 0xaa, 0x55 to device with address 0x20
        i2c.write(0x20, bytes([0xaa, 0x55]))
        # read 2 bytes from device with address 0x20
        i2c.read(0x20, 2)
        # write value 0x0f to register 0xaa of device at 0x20
        i2c.writeRegister(0x20, 0xaa.to_bytes(1, "big"), 0x0f.to_bytes(1, "big"))
        # read value of 1-byte register 0xaa of device at 0x20
        i2c.readRegister(0x20, 0xaa.to_bytes(1, "big"), 1)
```

### Basic SPI script
```python
from SmartWaveAPI import SmartWave

with SmartWave().connect() as sw:
    with sw.createSPIConfig() as spi:
        # write 0xaa, 0x55 via SPI and read simultaneously
        spi.write([0xaa, 0x55])
```

## Documentation
Further documentation can be found in our [documentation page](https://semify-eda.github.io/wfg-API/docs/html/index.html).
ARR-tool 0.0.4
A tool for making prediction
Requires Python: >=3.11

To execute the Python code on your system, first activate the environment:

1. Open the command prompt in the directory where the Python scripts are stored.
2. Start the virtual environment:
   - Command: `venv\Scripts\activate`
   - This creates a virtual environment where the Python libraries used in the scripts are installed.

Files and Their Functions:

- config.json: Contains the paths for the model, and the destination where the predicted Excel sheet needs to be stored.

- updateTable: Compares our table's latest awareness date with the latest awareness date of the SQL data and updates our excel sheet 'training_data.xlsx'.
  - Command for importing : 
      - from ARR_tool import updateTable
      - updateTable.update(config_path)

- modelTraining: Trains the model on the data prepared in the Excel sheet.
  - Command for importing :  
      - from ARR_tool import modelTraining
      - modelTraining.train(config_path)

- generate_prediction: Makes predictions for all the data on a specified date.
  - Command for importing :  
      - from ARR_tool import generate_prediction
      - generate_prediction.predict_decisions(pred_date,config_path)

- outlook: Sends the prepared predicted Excel sheet to the designated person.
  - Command for importing :  
      - from ARR_tool import outlook
      - outlook.send_mail(mail_to,subject,body,config_path)

This forms a cycle where, after some days, the model is updated. First, run `updateTable.py` to load all new data and update the `training_data.xlsx` Excel sheet, followed by model training and other processes.
mcdc-convergence-test 0.0.4
Tests certain mcdc functionality convergence to semi-analytical solutions provided by William Bennett
Requires Python: >=3.8

# mcdc_convergence_tests
Runs mcdc on given tests and plots convergence to benchmark data
## Dependencies
requires `numpy`,`hdf5`,and `mcdc`
## Installation guide
Download the `src` folder
## Quick start guide
The most user-friendly way of running the tests is as follows:
```
python -c 'import run; run.test([particlenums],"sourcetype",createdata,loud)' --mode=numba
```
where `particlenums` are the amounts of particles you'd like to use (e.g. `[1e2,1e3,1e4,1e5]`), and `sourcetype` is one of
```
"plane_IC"
"square_IC"
"square_source"
"gaussian_IC"
"gaussian_source"
"all"
```
`createdata` allows you to specify whether you want to run the mcdc simulations again, or use existing data (this is best used when you have run it with `createdata = True` once, then want to reuse that data without taking the time to compute it)
`loud` determines whether convergence is determined and plotted
`--mode=numba` makes computation much quicker, though this can be omitted and mcdc will run in normal python mode

IMPORTANT NOTE:

With the current implementation of MC/DC, the inclusion of `--mode=numba` is the only way to run in numba mode. This poses a problem when trying to run multiple simluations from one script, and so we recommend refraining from using the `all` option to create data, instead specifying each source. The `all` command can still be used to plot all the data with no problems.
rst2md 0.1.1
A utility and library to convert a reStructuredText document to Markdown.
Requires Python: >=3.9

======
rst2md
======

A utility and library to convert a reStructuredText document to Markdown.

.. note::

   This has been tested on a number of documents, but as of yet no test suite exists so it is likely
   incomplete.

.. note::

   Only plain reStructuredText documents are supported. There is no support for Sphinx extensions or
   similar.

Installation
------------

.. code-block::

    pip install --user rst2md

Usage
-----

This can be used as a library or from the command line.

As a library:

.. code-block:: python

    import pathlib
    from rst2md import convert_rst_to_md

    path = pathlib.Path('README.rst')
    with path.open('r') as f:
        data = f.read()

    md = convert_rst_to_md(path.name, data)

From the command line:

.. code-block:: bash

    python -m rst2md README.rst