semvec/pypi-packages huggingface dataset:
VoxelFarmClient 0.0.4
voxelfarm client
Requires Python: >=3.7

# Voxel Farm Client Package

This is a simple example package. You can use
[Voxelfarm PythonCookbook](https://www.voxelfarm.com/help/PythonCookbook.html)

to write your content.


## Initialize API
This example shows how to create a new instance of the Voxel Farm client Python API.


``` python

# Import the Voxel Farm Client Library
from VoxelFarmClient import voxelfarmclient

# The URL for the Voxel Farm API
vf_api_url = os.getenv('YOUR_VOXELFARM_API_URL')

# Create instance of the Voxel Farm REST API
vf = voxelfarmclient.rest(vf_api_url)

```

## Provide Credentials
This example shows how to provide credentials for API authentication.

``` python

# Set credentials
aad_app_secrets = os.getenv('AAD_APP_SECRETS')

if (aad_app_secrets!=None):
    vf.set_file_credentials(aad_app_secrets)

```

## Specify an HTTP proxy
This example shows how to specify an HTTP proxy to be used in all HTTP calls made by the API.

```
# Use a proxy to debug HTTP requests using Fiddler or similar
proxies = {
  "http": os.getenv('YOUR_PROXY_URL'),
}

# Set the proxy to debug HTTP calls
vf.set_proxy(proxies)

```

## Get CRS from project
This example shows how to retrieve the project's CRS (Coordinate Reference System).

``` python
# Get the coordinate system given project ID
result = vf.get_project_crs(project)

if not result.success:
    print(result.error_info)
    exit()
crs = result.crs

```
PyKingGen 0.0.5
Simple asyncio API wrapper for KingGen
Requires Python: >=3.6

# PyKingGen
Simple Python KingGen API wrapper

# Install
Use Python3 pip
* `python3 -m pip install PyKingGen`

Or

Build and installation instructions can be found here:
* https://packaging.python.org/en/latest/tutorials/packaging-projects/#generating-distribution-archives
* https://packaging.python.org/en/latest/tutorials/installing-packages/#installing-from-local-archives

# Usage
```py
import asyncio
from pykinggen import Client

client = Client("api-key")

async def main():
    return print(client.alt())

asyncio.run(main())
```

# IMPORTANT
Please note that I am a professional retard which means this code is as good as Xevier.
joltos 1.0
OS Image Builder
Keywords: alpine,debian

JoltOS
======

The aim of JoltOS is to become a framework for building custom Linux images
based on popular distributions, such as Debian, Ubuntu, Alpine, etc. Unlike
Yocto, the intention is not to build distributions from scratch, but to
utilize pre-built binaries to the greatest extent possible through publically
available Docker images and package repositories.


Prerequisites
-------------

JoltOS is built upon the Jolt task execution tool. Install both with:

  .. code-block:: bash

    $ pip install joltos

Python 3.9 or later is required.

JoltOS also needs Docker. Version 20 or later is recommended. The latest version can be installed with:

  .. code-block:: bash

    $ curl https://get.docker.com | sh

For cross-platform builds, the binfmt-support and qemu-user-static packages are required. 
Install them with your system's package manager:

  .. code-block:: bash

    $ sudo apt install -y binfmt-support qemu-user-static


Building an Image
-----------------

A minimal example image is available in the `examples/minimal` subdirectory. Build it by running this Jolt command:

  .. code-block:: bash

    $ jolt build minimal/debian:board=qemu


Customizing Images
------------------

Create a Jolt Python class inheriting either AlpineImage or DebianImage. 
Both base classes define different attributes that can be overridden to 
customize the image.

 - install_files - List of files to be copied into the image.
 - install_pkgs - List of packages to be installed using the distro package manager.
 - install_tasks - List of Jolt task artifacts to be copied into the image.
 - remove_files - List of files to remove from the image.
 - remove_pkgs - List of packages to be removed using the distro package manager.

Image formats are chosen using decorators:

 - joltos.attributes.squashfs - Builds a squashfs image
 - joltos.attributes.tar - Builds a tar archive

Multiple image types can be built at once. 

  .. code-block:: python

    @joltos.attributes.squashfs
    @joltos.attributes.tar
    class MinimalDebianRootfs(DebianRootfs):
      """ A minimal rootfs with systemd, as squashfs and tar images """
      name = "minimal/debian"
      install_pkgs = ["nano"]
      remove_files = [
        "/usr/share/doc",
        "/usr/share/man",
      ]


To build different variants of an image for different types of boards you 
can add conditional attributes that are selected based on the values of 
build parameters. Example:

  .. code-block:: python

    @joltos.attributes.tar
    @joltos.attributes.install_pkgs("install_pkgs_{board}")
    @joltos.attributes.install_pkgs("install_pkgs_{variant}")
    class MinimalDebianRootfs(DebianRootfs):
      """ A minimal rootfs with systemd, as squashfs and tar images """
      name = "minimal/debian"

      # This attribute is always selected
      install_pkgs = ["nano"]

      # This attribute is selected when variant=debug
      install_pkgs_debug = ["gdb"]

      # This attribute is selected when board=qemu
      install_pkgs_qemu = []

  .. code-block:: bash

    $ jolt build minimal/debian:board=qemu,variant=debug
CLGXRulesEngine 1.1.0
Rules Engine Subsystem with Azure functions!

# Rules Engine

The Rules Engine processes tasks that are sent by carriers and reconstruction companies – also known as tenants.

The Rules Engine provides the business logic for accomplishing assignments. Client organizations (tenants)
have unique business processes to handle claims. Many of these business processes are started by sending
an assignment - typically as a message in json or xml format. The Rules Engine implements the business logic
needed to create the workflow that accomplishes the assignment by creating new task(s).

As rules execute, new tasks are created and processed either by the Rules Engine or by people using web or mobile apps.
The orchestration of tasks occurs asynchronously using work queues that reside on the Azure cloud along with
API handlers, controllers, logic apps, etc. that are collectively referred to as Dispatch Task Manager.
The Rules Engine too is a component of the Dispatch Task Manager.


## Installation

```shell
git clone nextgear@vs-ssh.visualstudio.com:v3/nextgear/Dispatch.Application/Dispatch.Subsystems.RulesEngine
cd Dispatch.Subsystems.RulesEngine
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install -r requirements-dev.txt
make precommit
```

## Development

1. `git checkout -b <branch_name>`
2. Make changes
3. Bump version in setup.py
4. Add entry in CHANGELOG.md
5. Commit changes and raise Pull Request
6. Once request merge, create tag in VCS
7. Create and upload package in azure artifact.

## Create Package

```shell
make build
```
The package will be found in `dist/`

## Upload Package

```shell
pip install twine
twine upload --repository-url https://nextgear.pkgs.visualstudio.com/Dispatch.Application/_packaging/Dispatch.Subsystems.RulesEngine/pypi/upload dist/CLGXRulesEngine-<version_number>-py3-none-any.whl
```
For username and password prompt, enter your PAT details.
To create your PAT (personal access token), use link - https://nextgear.visualstudio.com/_usersSettings/tokens
Make sure your token has read/write access to upload package.

## Create Tag

```shell
git checkout main
git pull origin main
git tag <version_number>
git push origin <version_number>
```

## Running tests, coverage and linting

```shell
make tox
```

## Running directory cleanup

```shell
make clean
```

## Install package from branch

```shell
pip install git+ssh://nextgear@vs-ssh.visualstudio.com/v3/nextgear/Dispatch.Application/Dispatch.Subsystems.RulesEngine@<branch_name>
```