semvec/pypi-packages huggingface dataset:
panda-robot-server 0.0.0
Web Server to control the Franka Emika Panda robot.
Requires Python: >=3.8
Keywords: panda,robotics

# panda-robot-server

[![PyPI - Version](https://img.shields.io/pypi/v/panda-robot-server.svg)](https://pypi.org/project/panda-robot-server)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/panda-robot-server.svg)](https://pypi.org/project/panda-robot-server)

HTTP Server to control the Franka Emika Panda robot.

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install panda-robot-server
```

## License

`panda-robot-server` is distributed under the terms of the [MIT license](LICENSE).
Paul-Mathieu-package 0.0.1
A small example package
Requires Python: >=3.7

# M1-2022-git

## Introduction
This repository is a fork from the previous repository.
The bugs in the converter have been fixed and now we want to publish our work as a publicly available python package.

## Getting started
You should be working from **your own repository** that is a fork of M1-2022-git-workflow.
In order to run this project, you will have to follow these steps.
1. Clone this project
2. move into the project folder
``` shell
cd M1-2022-git-workflow
```
3. Set up a virtual environment
 * Create the virtual environment
 ```shell
 python -m venv myvenv
 ```
 * Activate venv
 ```shell
 . venv/bin/activate
 ```
4. Install pytest
```shell
pip install -U pytest
```
5. Execute main script
```shell
python main.py
```

## Instructions
### Merge feature branch into dev
Now that the converter has no more bugs, we want to merge our branch feature into the dev branch.
We will do a pull request (on your own repo). On GitHub, go to the "Pull requests tab" and click "New pull request".
Select *base* and *compare*. Remember : we want to merge *decimal-binary-converter* into *dev*. 
Then, *Create the pull request*. Add some description of the work you have done and publish the Pull Request.

**Note** : We could have just merge *decimal-binary-converter* into *dev* from the command line. However, when working on a real project, you probably won't have the rights to do so. Remember : dev is a public branch. So all the work going down there should be carefully reviewed and tested.


### Publish your work
We now have an awesome binary/decimal two ways converter ! It's time to publish it so the rest of the world can enjoy it !
We will publish it on PyPI (Python Package Index) which is a public repository of softwares for Python.
1. First, you have to create an account on [Pypi.org](https://pypi.org/)
2. Then, in your repository, you will find a [.github directory](/.github)
3. Inside this directory, you will find .yml files that defines workflows (using GitHub actions)
4. Open the yml files and take time to understand them. Do not hesitate to ask the teacher about them

#### Hands on !
5. We want to create a workflow that will, on publish, test our code and if tests succeed, then publish our package on PyPI
6. In GitHub, click on the *Actions* tab, then click on *new workflow*
7. Choose among the suggestions the template that best suits your use-case and click *Configure*
8. You may find some useful informations in the [Python documentation](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
9. When creating a release on GitHub, do not forget to create a tag corresponding to that release

#### Pull request
10. Once the workflow is setup and tested (you have published your package using it) you can open a pull request to the [original repository](https://github.com/rgt-yncrea/M1-2022-git-workflow)
poetry-lock-groups 1.0.0.dev0
Poetry extension enabling group dependency application at the lock stage
Requires Python: >=3.9,<4.0

This is a hyper-lightweight plugin which extends Poetry's group 
options (`--with`, `--without`, `--only`) to the `lock` command.  This
allows for sane behavior when providing the same package from 
different installation sources, organized by group.


### Installation
Execute the following command:
```shell
poetry self add poetry-lock-groups
```


### Use Case
In the course of a development lifecycle, there may be times in which
one wishes to use the same dependency from different sources.  This is
especially true within a CI lifecycle, where local development may
necessitate the use of local path dependencies, but remote deployment
precludes their usage.  In this case, rather than maintaining two
distinct versions of `pyproject.toml`, we may leverage dependency 
groups.

Vanilla Poetry recognizes dependency groups only at the `install` 
phase.  By advancing that recognition to the `lock` stage, we enable 
predictable, flexible patterns.

### Usage Example
Given the following `pyproject.toml`:
```toml
[tool.poetry]
name = "my-poetry-project"
version = "0.1.0.dev"
description = ""

[tool.poetry.dependencies]
python = "^3.9"

[tool.poetry.plugins."poetry.application.plugin"]
lock-groups-plugin = "poetry_lock_groups.plugin:LockGroupsPlugin"

[tool.poetry.group.remote.dependencies]
my-wheel-dependency = "^1.2.6"

[tool.poetry.group.local.dependencies]
my-wheel-dependency = {path = "../../my-wheel-dependency/"}

[build-system]
requires = ["poetry-core>=1.2"]
build-backend = "poetry.core.masonry.api"
```

By running the following command:

```shell
poetry lock --with remote --without local
```

This will generate a `poetry.lock` file that includes the dependency 
definitions within the `remote` group, but without those in the
`local` group.  Note that if we included both groups, or simply 
refrained from specifying group usages, we would see behavior 
identical to that in vanilla Poetry, which is, in this case, undefined.

Note that the following sequence of commands may fail:
```shell
poetry lock --without local
poetry install --with local
```
This is because the `poetry install` command searches the lockfile
to install dependencies.  By building the lock file without the `local`
group, any dependencies that exist only within that group will have
no known sources, rendering them unresolvable.


### Warning
This plugin exclusively modifies lock operations initiated explicitly
via the `lock` command.  It makes no attempt to modify behavior resulting
from an implied lock, such as when running `poetry install` without
having already created a lock file.
streamlit-camera-input-live 0.2.0
Alternative version of st.camera_input which returns the webcam images live, without any button press needed
Requires Python: >=3.7

# streamlit-camera-input-live

[![PyPI version](https://img.shields.io/pypi/v/streamlit-camera-input-live.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/streamlit-camera-input-live/)
[![PyPI downloads](https://img.shields.io/pypi/dm/streamlit-camera-input-live.svg)](https://pypistats.org/packages/streamlit-camera-input-live)
[![GitHub](https://img.shields.io/github/license/blackary/streamlit-camera-input-live.svg)](LICENSE)
[![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)

Alternative version of st.camera_input which returns the webcam images live, without any button press needed

[![Open in Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://camera.streamlitapp.com)

## Installation instructions

```sh
pip install streamlit-camera-input-live
```

## Usage instructions

```python
import streamlit as st

from camera_input_live import camera_input_live

image = camera_input_live()

st.image(value)
```