semvec/pypi-packages huggingface dataset:
robotcloud 0.1.2
Client to interact with robotcloud API from a python project.
Keywords: client robotcloud

# PYTHON ROBOTCLOUD API CLIENT

Python library to access robotcloud endpoints.

## Installation

```bash
pip install robotcloud
```
### Environment variables

The environment where your application is running must define the next environment variables
to be able to interact with robotcloud:
- **ROBOTCLOUD_API_KEY**: Should contain the api key of the robotcloud instance you want to interact.  
- **ROOT_URL**: Should contain the base URL which point to the robotcloud instance. 
In a local environment can be something like "http://127.0.0.1:8080/robotcloud/1.2"
eals 0.9.6
eALS - Element-wise Alternating Least Squares
Requires Python: >=3.8,<3.11

# eALS - Element-wise Alternating Least Squares

A Python implementation of the element-wise alternating least squares (eALS) for fast online matrix factorization proposed by [arXiv:1708.05024](https://arxiv.org/abs/1708.05024).

## Prerequisites

- Python >= 3.8, < 3.11

## Installation

```sh
pip install eals
```

## Usage

```python
import numpy as np
import scipy.sparse as sps
from eals import ElementwiseAlternatingLeastSquares, load_model

# batch training
user_items = sps.csr_matrix([[1, 2, 0, 0], [0, 3, 1, 0], [0, 4, 0, 4]], dtype=np.float32)
model = ElementwiseAlternatingLeastSquares(factors=2)
model.fit(user_items)

# learned latent vectors
model.user_factors
model.item_factors

# online training for new data (user_id, item_id)
model.update_model(1, 0)

# rating matrix and latent vectors will be expanded for a new user or item
model.update_model(0, 5)

# current rating matrix
model.user_items

# save and load the model
model.save("model.joblib")
model = load_model("model.joblib")
```

See the [examples](examples/) directory for complete examples.

## Development

### Setup development environment

```sh
git clone https://github.com/newspicks/eals.git
cd eals
poetry run pip install -U pip
poetry install
```

### Tests

```sh
poetry run pytest
```

Set `USE_NUMBA=0` for faster testing without numba JIT overhead.

```sh
USE_NUMBA=0 poetry run pytest
```

To run tests against all supported Python versions, use [tox](https://tox.readthedocs.io/).
You may need to add the Python versions in the `tox.ini` file.

```sh
poetry run tox
```
diacalculator 1.0.0
This is very basic calculator

# diacalculator

Under construction! Not ready for use yet! Currently experimenting and planning!

Developed by Nazmul Haque from DIA (c) 2023

## Examples of How To Use (DIA Calculator)

Creating A Calculator

```python
def add_numbers(a,b):
    return a+b

def sub_numbers(a,b):
    return a-b
def mul_numbers(a,b):
    return a*b
def div_numbers(a,b):
    return a/b

```



Check out: https://www.dia.com/
bentoutils 1.1.2
Utilities for working with BentoML V1.x
Requires Python: >=3.6

# bentoutils

## Contents

Console scripts for:

1. bentopack - package an existing pretrained model and save to the Model Registry

```
Usage: bentopack [OPTIONS]

Options:
  --module TEXT  fully qualified module name containing service to package
  --clz TEXT     class name of service to package
  --name TEXT    model name
  --path TEXT    directory path of pretrained model
  --help         Show this message and exit.
```

Example:
```
bentopack \
    --module TopicBentoService \        # python module containing service class
    --clz TopicBentoService \           # service class
    --name tm_train3_roberta_l_weigh \  # pretrained model name
    --path /srv/models/multilabel-topic # local path to pretrained model (excluding name)
```

2. deploy_to_knative - WIP


Uses Kaniko

kaniko is a tool to build container images from a Dockerfile, inside a container or Kubernetes cluster.

kaniko solves two problems with using the Docker-in-Docker build method:

* Docker-in-Docker requires privileged mode to function, which is a significant security concern.
* Docker-in-Docker generally incurs a performance penalty and can be quite slow.

The setting `--isdockerconfig` is required when using a private registry such as Harbor.

We can build a Docker image with kaniko and push it to Docker Hub or any other standard Docker registry.

To push to DockerHub or any other username and password Docker registries we need to mount the Docker config.json file that contains the credentials. Caching will not work for DockerHub as it does not support repositories with more than 2 path sections (acme/myimage/cache), but it will work in Artifactory and maybe other registry implementations.

    DOCKER_USERNAME=[...]
    DOCKER_PASSWORD=[...]
    AUTH=$(echo -n "${DOCKER_USERNAME}:${DOCKER_PASSWORD}" | base64)
    cat << EOF > config.json
    {
        "auths": {
            "https://index.docker.io/v1/": {
                "auth": "${AUTH}"
            }
        }
    }
    EOF

Alternatively, to create a secret to authenticate to Google Cloud Registry, follow these steps:

1. Create a service account in the Google Cloud Console project you want to push the final image to with Storage Admin permissions.
2. Download a JSON key for this service account
3. Rename the key to kaniko-secret.json
4. To create the secret, run:

    kubectl create secret generic kaniko-secret --from-file=<path to kaniko-secret.json>

Note: If using a GCS bucket in the same GCP project as a build context, this service account should now also have permissions to read from that bucket.

See https://github.com/GoogleContainerTools/kaniko
ez-query 0.0.3
SQL Query Generator (using your table schemas) powered by ChatGPT.
Requires Python: >=3.8

# Ez-Query
## SQL Query Generator Powered by ChatGPT

Ez_query allows you to generate sql queries using ChatGPT with the added benefit of retrieving your table schemas for you. 

ChatGPT is capable of helping you write SQL queries but only if you provide it your table schemas first. This would mean you have to retrieve them youself manually and enter them into ChatGPT. Doing this multiple times is tedious and time-consuming. 

Ez_query makes the process of retrieving your table schemas extremely simple and allows you to do this all in the terminal.

## Installation


```sh
pip install ez_query
```
## Usage

```sh
ez_query -h
ez_query --openai_api_key sk-fake-key --db_host=localhost --db_user=root --db_pass=root --db_name=employees
```

![image](https://user-images.githubusercontent.com/21690974/223022847-17d2ebb5-a007-458d-b3ab-2fa7e8df2bf6.png)

![image](https://user-images.githubusercontent.com/21690974/223022837-1ca6e0ac-2934-4242-b6cd-13e05fbcabd9.png)
plinky 0.1
Dynamic link site>
Requires Python: >=3.10

# Plinky

Dynamic link site

[![version](https://img.shields.io/pypi/v/plinky.svg)](https://pypi.org/project/plinky)
[![license](https://img.shields.io/pypi/l/plinky.svg)](https://github.com/amyreese/plinky/blob/main/LICENSE)

Install
-------

```shell-session
$ pip install plinky
```

License
-------

Plinky is copyright Amethyst Reese, and licensed under the MIT license.