semvec/pypi-packages huggingface dataset:
bronzebeard 0.2.2
Minimal ecosystem for bare-metal RISC-V development
Requires Python: >=3.6

Bronzebeard
===========
Bronzebeard is a simple, standalone assembler for developing bare metal `RISC-V <https://en.wikipedia.org/wiki/Riscv>`_ programs.
It is designed for applications that stand on their own without relying on `operating systems <https://en.wikipedia.org/wiki/Operating_system>`_, frameworks, SDKs, or pre-existing software of any kind.
This assembler supports the base 32-bit instruction set as well as the M, A, and C extensions (RV32IMAC).

Bronzebeard and its tools are implemented purely in Python.
It has been written in order to be free from large, complex toolchains.
This keeps the project portable, minimal, and easy to understand.

Motivation
----------
Much of modern software has accrued vast amounts of bulk and complexity throughout the years.
Can useful software be developed without relying on any of it?
That's the question that this project seeks to answer.
I believe that the rise of RISC-V provides a great opportunity to explore different methods of program development.
Installing a full operating system doesn't have to be a prerequisite to building something useful.

Check out the `DerzForth <https://github.com/theandrew168/derzforth>`_ project for further elaboration of this idea.

Installation
------------
If you are unfamiliar with `virtual environments <https://docs.python.org/3/library/venv.html>`_, I suggest taking a brief moment to learn about them and set one up.
The Python docs provide a great `tutorial <https://docs.python.org/3/tutorial/venv.html>`_ for getting started with virtual environments and packages.

Bronzebeard can be installed via pip::

  pip install bronzebeard

Or, if you'd rather clone this repo and play with the examples::

  git clone https://github.com/theandrew168/bronzebeard.git
  cd bronzebeard/
  # I'd still create and activate a virtual environment here
  pip install -e .

Assemble!
---------
First, create a text file with some RISC-V assembly source code in it::

  add x1, x2, x3
  add x4, x5, x6

Then, with Bronzebeard installed::

  bronzebeard my_asm_file.asm

By default, the assembled output binary will be placed in a file named :code:`bb.out`.

Testing
-------
Bronzebeard's tests are written using `pytest <https://docs.pytest.org/en/6.2.x/>`_::

  pip install pytest

Once installed, the tests can be run via::

  pytest
ninjalinker 0.0.7
NinjaLinker : A secure Python-based CLI VPN tool developed on top of WireGuard


Ninjalinker
============
[![PyPI version](https://badge.fury.io/py/ninjalinker.svg)](https://badge.fury.io/py/ninjalinker) 
[![Downloads](https://static.pepy.tech/badge/ninjalinker)](https://pepy.tech/project/ninjalinker)\
Please read\
Documentation and README.md first.
documentation can also be read online at:\
[https://docs.selfmade.ninja/ninjalinker](https://docs.selfmade.ninja/docs/category/ninjalinker)
subgen 0.0.1
Subdomain wordlist generator
Requires Python: >=3.6

# subdomain_wordlist_gen (aka subgen)
Subdomain wordlist generator

Github: [@shriyanss/subdomain_wordlist_gen](https://github.com/shriyanss/subdomain_wordlist_gen)

## Table of contents
- [Installation](#installation)
    - [Install using `pip` (recommended)](#install-using-pip-recommended)
    - [Install using `setup.py` file](#install-using-setuppy-file)
- [Usage](#usage)
    - [Generate a simple wordlist using the given subdomains file](#generate-a-simple-wordlist-using-the-given-subdomains-file)

## Installation
### Install using `pip` (recommended)
```
pip install subgen
```
OR
```
pip3 install subgen
```

**NOTE: When tested on mac OS, installing without sudo didn't worked as expected, so consider running above commands as root instead**

### Install using `setup.py` file
```
sudo python setup.py install
```
OR
```
sudo python3 setup.py install
```

## Usage
```
usage: subgen-runner.py [-h] -i INPUT [-s] [-o OUTPUT]

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input file to generate wordlist with
  -s, --silent          Don't print the banner
  -o OUTPUT, --output OUTPUT
                        Output file to write the wordlist
```

### Generate a simple wordlist using the given subdomains file
This will split and then print the results.

Example:-
```
$ cat subdomains.txt
www.example.com
blog.example.com
store.example.com
forum.example.com
support.example.com
news.example.com
app.example.com
mail.example.com
forum.example.com
events.example.com
partners.example.com
```
```
$ subgen -i subdomains.txt
               __                   
   _______  __/ /_  ____ ____  ____ 
  / ___/ / / / __ \/ __ `/ _ \/ __ \
 (__  ) /_/ / /_/ / /_/ /  __/ / / /
/____/\__,_/_.___/\__, /\___/_/ /_/ 
                 /____/             

www
blog
store
forum
support
news
app
mail
events
partners
```
h5image 0.4.1
Load and save images to HDF5 files
Requires Python: >=3.6
Keywords: hdf5,image,map

# h5image

This package provides standard functions for interacting with HDF5 files as
part of the CriticalMAAS project.

This package will create HDF5 files with the following structure:

- group : all data associated with a single map
    - `json` : the raw json file used to create the map and layers
    - `map` : the actual map image
        - `data` : the actual bytes of the image
        - `corners` : the corners of the map where layers have data
        - `patches` : for each layer (key) a list of patches as a tuple (x, y)
        - `layers_patch` : for each patch (key is x_y) a list of layers
        - `valid_patche`  : a list of locations across all layers as a tuple (x, y)
    - `<layer>` : a layer of the map, the name of the layer is the name of file
        - `data` : the actual layer data
        - `patches` : a list of patches as a tuple (x, y) for this specific layer

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

Install using pip:

```
pip install h5image
```

To convert a folder of images to a HDF5 file use the `h5create` program.

Quickstart example
------------------

The following code will create a new HDF5 file with a map and a layer, find the
patch with most layers, and load the map and the layers at that patch.

```python
import matplotlib.pyplot as plt
import numpy as np
import rasterio
from h5image import H5Image

# create map file
map = "CA_Sage"
h5i = H5Image(f"{map}.hdf5", "w")
h5i.add_image(f"{map}.json", folder="./data")

# get biggest patch
patches = h5i.get_patches(map, True)
sorted_patches = {k: v for k, v in sorted(patches.items(), key=lambda item: len(item[1]), reverse=True)}
loc, loc_layers = next(iter(sorted_patches.items()))
row = int(loc.split("_")[0])
col = int(loc.split("_")[1])
print(f"Biggest number of layers ({len(loc_layers)}) for {map} is at ( {row}, {col})")

# plot map
rgb = h5i.get_patch(row, col, map)
plt.imshow(rgb)
plt.title('map')
plt.axis('off')
plt.show()

# plot layers and legend
for layer in loc_layers:
    rgb = h5i.get_patch(row, col, map, layer=layer)
    plt.imshow(rgb, cmap=plt.colormaps['plasma'])
    plt.title(layer)
    plt.axis('off')
    plt.show()

    rgb = h5i.get_legend(map, layer)
    plt.imshow(rgb)
    plt.title("legend")
    plt.axis('off')
    plt.show()

# saving image as geotiff
# can also use h5i.save_image(map, 'map')
dset = h5i.get_map(map)
if dset.ndim == 3:
    image = dset[...].transpose(2, 0, 1)  # rasterio expects bands first
else:
    image = np.array(dset[...], ndmin=3)
rasterio.open(f"{map}.tif", 'w', driver='GTiff', compress='lzw',
              height=image.shape[1], width=image.shape[2], count=image.shape[0], dtype=image.dtype,
              crs=h5i.get_crs(map, layer), transform=h5i.get_transform(map, layer)).write(image)

# close file
h5i.close()
```
python-gerber 0.1.0
Python parser for Gerber and NC Drill Files

# Python Gerber Library
This library provides a simple and elegant parser for Gerber and NC Drill files. It's written in pure Python and supports all Gerber commands, including most deprecated ones.

# File Structure
```
.
├── pygerber
│   ├── aperture.py
│   ├── drill_layer.py
│   ├── gerber_layer.py
│   └── renderers
│   │   |   # Renders a Gerber file as an SVG
│   │   └── svg.py
│   └── standards
│       │   # Enums of Gerber file format
│       ├── gerber.py
│       |   # Enums of NC Drill file format
│       └── nc_drill.py
└── tests
    |   # All unit tests for this package
    └── test_package.py  
```

# Features
- [x] Gerber X2 file parser
    - [x] Reading gerber layer
    - [x] Writing gerber layer
- [x] NC Drill file parser
    - [x] Reading X2 standard files
    - [x] Writing drill files
    - [x] API for drill operations
    - [x] API for rout operations
- [ ] SVG rendering
    - [x] Drill operations
    - [x] Linear rout operations
    - [ ] Circular rout operations
    - [x] Gerber flash operations
    - [x] Gerber linear interpolations
    - [ ] Gerber circular interpolations

# Running Unit Tests
Place gerber files in the `testdata` folder and run the unit tests:
```
pytest
```

# References
- [Gerber Standard](https://www.ucamco.com/files/downloads/file_en/399/the-gerber-file-format-specification-revision-2020-09_en.pdf)
- [NC Drill Standard](https://www.ucamco.com/files/downloads/file_en/305/xnc-format-specification_en.pdf)