semvec/pypi-packages huggingface dataset:
robot-folders 0.7.0
robot_folders is your workspace handling utility around the ROS ecosystem.
Requires Python: >=3

|license_badge| |codecov_badge| |doc_badge|


Robot Folders
=============

Welcome to ``robot_folders``! ``robot_folders`` is a collection of utility scripts designed to
streamline and facilitate the management of workspaces used for (ROS) development. It is designed
to enhance efficiency in handling different environments, consisting of multiple workspaces like a
``catkin_workspace`` and ``colcon_workspace`` or a plain CMake workspace.

It focuses on optimizing the management of various subworkspaces, contributing
to a seamless development experience.


Documentation
-------------
Documentation can be found on `our GH pages <https://fzi-forschungszentrum-informatik.github.io/robot_folders/>`_.


Quick start
------------

It is recommended to install robot_folders using ``pipx`` (You can install ``pipx`` using ``sudo apt
install pipx``).

.. code:: bash

   pipx install robot-folders

Upgrade
^^^^^^^

To upgrade robot_folders using ``pipx`` do

.. code:: bash

   pipx upgrade robot-folders

Shell setup
^^^^^^^^^^^

In order to use ``robot_folders`` you'll have to call its source file. How to do this depends on
the way you installed ``robot_folders`` and on the version of the installation tool.

In case you have installed
``robot_folders`` using ``pipx`` as described above (and given you use the bash shell), do:

.. code:: bash

   # pipx < 1.3.0 or if ${HOME}/.local/pipx already existed
   echo "source ${HOME}/.local/pipx/venvs/robot-folders/bin/rob_folders_source.sh" >> ~/.bashrc
   # pipx >= 1.3.0
   echo "source ${HOME}/.local/share/pipx/venvs/robot-folders/bin/rob_folders_source.sh" >> ~/.bashrc

In case you manually installed ``robot_folders`` using a python virtualenv the path is similarly

.. code:: bash

   echo "source <your-virtualenv-path>/bin/rob_folders_source.sh" >> ~/.bashrc


Basic usage
^^^^^^^^^^^

After installation open up a new terminal to use robot_folders. The main
command for using robot_folders is ``fzirob``. Type

.. code:: bash

   fzirob --help

to get an overview over all available commands.



.. |license_badge| image:: https://img.shields.io/github/license/fzi-forschungszentrum-informatik/robot_folders?color=yellow
   :alt: GitHub License

.. |codecov_badge| image:: https://codecov.io/gh/fzi-forschungszentrum-informatik/robot_folders/graph/badge.svg?token=85HNG0NCEI
 :target: https://codecov.io/gh/fzi-forschungszentrum-informatik/robot_folders
.. |doc_badge| image:: https://img.shields.io/badge/Documentation-Github_Pages-blue
 :target: https://fzi-forschungszentrum-informatik.github.io/robot_folders/index.html
marquez-python 0.50.0
Marquez Python Client
Requires Python: >=3.6
Keywords: marquez

# Marquez Python Client

Python client for [Marquez](https://github.com/MarquezProject/marquez).

## Documentation

See the [API docs](https://marquezproject.github.io/marquez/openapi.html).

## Requirements

* [Python 3.6](https://www.python.org/downloads)+

## Installation

```bash
$ pip3 install marquez-python
```

To install from source run:

```bash
$ python3 setup.py install
```

## Usage

### Reading Metadata
```python
from marquez_client import MarquezClient

client = MarquezClient(url='http://localhost:5000')

# list namespaces
client.list_namespaces()
```

To enable logging, set the environment variable `MARQUEZ_LOG_LEVEL` to `DEBUG`, `INFO`, or `ERROR`:

```
$ export MARQUEZ_LOG_LEVEL='INFO'
```

### Writing Metadata
To collect OpenLineage events using Marquez, please use the [openlineage-python](https://pypi.org/project/openlineage-python/) library. OpenLineage is an Open Standard for lineage metadata collection designed to collect metadata for a job in execution.

## Development

To install all dependencies for _local_ development:

```bash
$ pip3 install -e .[dev]
```

To run the entire test suite:

```bash
$ pytest
```

----
SPDX-License-Identifier: Apache-2.0
Copyright 2018-2023 contributors to the Marquez project.
py-zkp 0.1.0
py-zkp: ZKP in python including groth16, plonk, tokamak_snarks
Requires Python: <4,>=3.8
Keywords: zkp

# py_zkp

This is complementaly project of [ZKP study series postings(WIP)](https://www.notion.so/tokamak/6e59b0e13af24a83ae50a10cd59dfbfa?pvs=4)

This is a library that allows you to verify Python code with various ZKP algorithms, including groth16 and plonk.
Using this library, you can convert Python code to QAP and use functions for the entire ZKP process, including setup, proving, and verifying.

# Quickstart

```
python -m pip install py_zkp
```

# Developer Setup

### Development Environment Setup

You can set up your dev environment with:

```
git clone https://github.com/tokamak-network/py_zkp.git
cd py_zkp
python3 -m venv venv
. venv/bin/activate
python -m pip install -e ".[dev]"
```
cxrandomwalk 0.5.9
Library to perform random walks on complex networks.
Requires Python: >=3.9

# CXRandomWalk

Fast library written in C for python to generate sentences based on random walks from networks. Can be used to generate input data for word2vec and other embedding techniques.

## Install

Requires python headers and a C11 compatible compiler, such as gcc or clang.

To install it, simply run:

```bash
pip install cxrandomwalk
```

or clone this repository and install it from master by running:

```bash
pip install git+git://github.com/filipinascimento/cxrandomwalk.git
```
## Usage
The walking algorithm uses regular random walks and biased random walks according to node2vec ([https://snap.stanford.edu/node2vec/]).

Step 1: Import the libraries

```python
import numpy as np
import cxrandomwalk as rw
```

Step 2: Convert network to a edgelist and a list of weights (optional)

```python
vertexCount = 10;
edges = np.random.randint(0,vertexCount-1,(vertexCount*2, 2))
weights = np.random.random(size=vertexCount*2);
```

Step 3: Load the network data in an agent object

```python
agent = rw.Agent(vertexCount,edges,False,weights)
```

To generate the sequences use: 
```python
sequences = agent.generateWalks(p=2,q=3,verbose=True)
```

The output is a list of lists with the walks.


## API Documentation
```python
cxrandomwalk.Agent(vertexCount,edges,directed=False,weights=None)
```
- `vertexCount` - number of vertices in the network
- `edges` - list of edges 
- `directed` - directed or not
- `weights` - list containing the weights of the edges (use the same order as edges)
~returns a rw.Agent instance~ 

```python
cxrandomwalk.Agent.generateWalks(p=1.0,q=1.0,windowSize=80,walksPerNode=10,verbose=False,filename=None,callback=None,updateInterval=1000)
```
- `p` - for p in node2vec walks (1.0 for unbiased) 
- `q` - for q in node2vec walks (1.0 for unbiased) 
- `windowSize` - length of each walk 
- `walksPerNode` - number of sentences to be generated 
- `verbose` - enable verbose mode
- `filename` - save sentences to filename instead of returning the sequences
- `callback` - callback function that runs 
- `updateInterval` - set the interval between iterations so that python interruptions work 

returns a list of lists containing the sequences. If filename is provided, instead of returning a list, the method creates the file and fill with the walks, with words separated by spaces and sentences separated by new lines. It can be used directly on gensim.

## TODO
- Include other kinds of walks
- Better documentation and CLI help


## Example with tqdm callback

```python
import numpy as np
import cxrandomwalk as rw
from tqdm.auto import tqdm 

vertexCount = 10000;
edges = np.random.randint(0,vertexCount-1,(vertexCount*2, 2))
weights = np.random.random(size=vertexCount*2);

agent = rw.Agent(vertexCount,edges,False,weights)

def make_pbar():
  pbar = None
  def inner(current,total):
    nonlocal pbar
    if(pbar is None):
      pbar= tqdm(total=total);
    pbar.update(current - pbar.n)
  return inner

print(len(agent.generateWalks(q=1.0,p=1.0,verbose=False,updateInterval=1000,callback=make_pbar())))

```
muse-basic-tcp-client 0.0.1
Muse Basic TCP Client in python
Requires Python: >=3.8

# Muse Basic TCP client -- _used to control TCP devices over the network_

## Intent
* A TCP socket client that can send either str or bytes.

### Features

* Rate Limiting -- sets the number of messages per second
* Connection Status -- allows a callback to be assigned for when the connection is made or dropped