semvec/pypi-packages huggingface dataset:
lads-opcua-client 0.1.0
A python client for LADS OPC UA Server
Requires Python: >=3.12

## Python Client for LADS OPC UA Server
Create a connection to the LADS Server using the server URL:

```python
conn = Connection("your_server_url")
```
<br>

Start the connection to the server:

```python
conn.connect()
```
<br>

Get the server object of the Connection class

```python
serv = conn.server
```
<br>

Get the LADS Device list that is present in the LADS Server DeviceSet

```python
devices = serv.devices
```
<br>

For a Device 'i' the list of Functional Units present inside that Device can be retrieved as

```python
fu = devices[i].functional_units
```
<br>

The Function Set present inside a Functional Unit 'k' can be accessed as

```python
fs = fu[k].function_set
```
<br>

The list of Functions present inside the Function Set can be retrieved as 

```python
funcs = fs.functions
```
Please be aware, that LADS specifies numerous function types, representing e.g. sensors, controllers, timers, lids/doors and so on. For further information refer to the [specification](https://reference.opcfoundation.org/LADS/v100/docs/) and the [workshop example](https://github.com/opcua-lads/workshop).
<br>

Variables, methods and objects of a function can be easily accessed as properties, e.g.
the Sensor Value of a Sensor Function 'j' can be accessed as 

```python
value = funcs[j].sensor_value.value

```
<br>

The connection to the server can be disconnected as 

```python
conn.disconnect()
```

<br><br>
airo-drake 0.0.8
Integration between airo-mono and Drake.
Requires Python: >=3.10

# airo-drake
Python package to simplify working with [Drake](https://drake.mit.edu/) in combination with  [`airo-mono`](https://github.com/airo-ugent/airo-mono).

**Key motivation:**
  - 🔋**Batteries included:** Drake is a powerful robotics toolbox, but it can have a steep learning curve.
If you've worked with Drake, you likely ended up deep in the [C++ documentation](https://drake.mit.edu/doxygen_cxx/index.html) or in Russ Tedrake's [manipulation repo](https://github.com/RussTedrake/manipulation) looking for guidance. `airo-drake` aims to be a *batteries included* Python package to get you up and running quickly with your own robot scenes in Drake!

## Overview 🧾
**Use cases** - we currently use Drake mainly for:
  - 🎨 Visualization
  - 💥 Collision checking
  - ⏱️ Time parameterization of paths

**Features:**
  - 🏗️ Help building scenes
  - 📈 Visualization functions for TCP poses, IK solutions, robot arm trajectories
  - 🔄 Converting `airo-mono` types to Drake types

**Design choices:**
 - 🍃 **Lightweight:** We try to limit duplicating or wrapping Drake, and prefer adding examples over convenience functions.
  - 🔓 **Opt-in:** drake can function as full blown physics simulator, but for many use cases you dont need it, so we make sure this is opt-in.

## Getting started 🚀
Complete the [Installation 🔧](#installation-🔧) and then dive right into the [notebooks 📔](./notebooks/)!

## Installation 🔧
`airo-drake` is available on PyPi and installable with pip:
```
pip install airo-drake
```
However it depends on `airo-typing` from [`airo-mono`](https://github.com/airo-ugent/airo-mono) which is not on PyPi, so you have to install that yourself.

## Developer guide 🛠️
See the [`airo-mono`](https://github.com/airo-ugent/airo-mono) developer guide.
A very similar process and tools are used for this package.

### Releasing 🏷️
See [`airo-models`](https://github.com/airo-ugent/airo-models/tree/main), releasing `airo-drake` works the same way.
airo-models 0.0.12
Curated URDFs and 3D models of the robots and gripper used at airo.
Requires Python: >=3.10

# airo-models
Curated URDFs and 3D models of the robots and gripper used at airo.

## Installation
`airo-models` is available on PyPi and can be installed with pip:
```
pip install airo-models
```

## Usage
Example of loading a URDF from airo-models, customizing it and writing it to a temporary file:
```python
import airo_models

robotiq_urdf_path = airo_models.get_urdf_path("robotiq_2f_85")
robotiq_urdf = airo_models.urdf.read_urdf(robotiq_urdf_path)

# Make the robotiq gripper static
airo_models.urdf.replace_value(robotiq_urdf, "@type", "revolute", "fixed")
airo_models.urdf.delete_key(robotiq_urdf, "mimic")
airo_models.urdf.delete_key(robotiq_urdf, "transmission")

# Write it to a temporary file to read later with Drake's AddModelFromFile
robotiq_static_urdf_path = airo_models.urdf.write_urdf_to_tempfile(
    robotiq_urdf, robotiq_urdf_path, prefix="robotiq_2f_85_static_"
)
```

To check which models are available:
```python
from airo_models.files import AIRO_MODEL_NAMES

print(AIRO_MODEL_NAMES)

>>> ['ur3e', 'ur5e', 'robotiq_2f_85']
```

## Modeling conventions
The standard convention we follow is X+ forward, Z+ up.

For cameras, we follow Z+ forward through the eye of the camera, X+ right. The origin of the camera is at the center of the (left) lens. Left is defined egocentric of the camera (i.e. looking out of the eyes of the camera).

For grippers, we follow Z+ pointing outwards from the fingers and X in the direction in which the parallel gripper closes its fingers. The origin of the gripper (`base_link`) is at the mounting point of its base.

## Development
### Local installation

- Clone this repo
- Install the dependencies using `uv sync`
- Initialize the pre-commit hooks `uv run pre-commit install`
- Run the tests with `uv run pytest .`

### Releasing
Releasing to PyPi is done automatically by github actions when a new tag is pushed to the main branch.
1. Update the version in `pyproject.toml`.
2. ``` git add pyproject.toml```
3. ``` git commit -m ""```
4. ``` git push```
5. ```git tag -a v0.1.0 -m "airo-models v0.1.0"```
6. ```git push origin v0.1.0```

This was set up following [this guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/) first and then [this guide](https://packaging.python.org/en/latest/guides/publishing-package-distribution-releases-using-github-actions-ci-cd-workflows/).
polly-python 4.5.0
Polly SDK
Requires Python: <3.15,>=3.9

[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
![code-coverage](https://github.com/ElucidataInc/polly-python-code/blob/badges_do_not_delete/badges/badge.svg)
![Linting](https://img.shields.io/badge/Linting-Black-green)
![Version](https://img.shields.io/badge/python-3.7%2B-blue)

# About Polly Library

This package is intended to be used by Polly users - bioinformaticians, data scientists, and life science researchers - working in drug discovery and development.

# Installation

Polly-python can be installed by running:

```python
pip install polly-python
```
 
# Key features:

* Discover biomedical datasets specific to their research requirements by querying omixatlas which have a well-defined schema and curated metadata fields. 
* Expanding the query by using ontological mappings for diseases.
* Download the datasets of interest and use them for further enrichment and analysis using other open-source bash, R and Python packages commonly used in life-science research.
* Seamlessly interact with the Schema of the OmixAtlas by using fetch, update, and post functions.
* Create new Workspaces and fetch the list of existing ones.
* Upload and Download files and folders from Workspace.
* Save dataset of interest from OmixAtlas to Workspace.

# Get Started

* Examples of characteristics and functions of polly-python can be found as Jupyter Notebook [here](https://github.com/ElucidataInc/polly-python). 
* Full documentation available [here](https://docs.elucidata.io/OmixAtlas/Polly%20Python.html).

# Contributing Guidelines

* Refer to the `CONTRIBUTING.md` file for detailed information

# Contacts
If you have questions, suggestions or problems, feel free to open an issue [here](https://github.com/ElucidataInc/polly-python/issues).

You can contact us at:
* kapil.kumar@elucidata.io
* jainik.dedhia@elucidata.io
lynxpresence 4.6.2
Discord RPC client written in Python
Requires Python: >=3.9
Keywords: discord, rich presence, lynxpresence, rpc, api, wrapper, gamers, chat, irc

Forked as upstream did not make a release in quite a while, I hope to kill this fork off in the future.

I recommend doing `import lynxpresence as pypresence` to keep compatibility and allow easy switching in case upstream picks up again.

> A Discord Rich Presence Client in Python? Looks like you've come to the right place.

![PyPI](https://img.shields.io/pypi/v/lynxpresence.svg?style=for-the-badge)

----------

# Installation

Install pypresence with `pip`, for the latest development version:

```shell
pip install https://github.com/C0rn3j/lynxpresence/archive/master.zip
```

For the latest stable version:

```shell
pip install lynxpresence
```

----------

# Documentation

> [!Note]
> You need an **authorized app** to do anything besides rich presence!

####  [pypresence Documentation](https://qwertyquerty.github.io/pypresence/html/index.html)
####  [Discord Rich Presence Documentation](https://discord.com/developers/docs/rich-presence/how-to)
####  [Discord RPC Documentation](https://discord.com/developers/docs/topics/rpc)
####  [pyresence Discord Support Server](https://discord.gg/JF3kg77)
####  [Discord API Support Server](https://discord.gg/discord-api)

----------

# Examples

Examples can be found in the [examples](https://github.com/C0rn3j/pypresence/tree/master/examples) directory, and you can contribute your own examples if you wish, just read [examples.md](https://github.com/C0rn3j/pypresence/blob/master/examples/examples.md)!

----------

# Development

Want to contribute? Check out the **[Development Guide](DEVELOPMENT.md)** for setup instructions, testing, code quality tools, and contribution guidelines.
metsuperq 0.1.0
A project to define standards for analysis functions of experimental data in the MetSuperQ project.
Requires Python: >=3.11
Keywords: metsuperq, quantum, analysis, data, standards

# MetSuperQ

[![PyPI version](https://img.shields.io/pypi/v/metsuperq.svg)](https://pypi.org/project/metsuperq/)
[![Python versions](https://img.shields.io/pypi/pyversions/metsuperq.svg)](https://pypi.org/project/metsuperq/)
[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](LICENSE)

Quantum measurement analysis with integrated InfluxDB time-series storage.

## Features

- **Quantum Measurement Analysis**: T1, T2 echo, and T2 Ramsey measurement analysis
- **InfluxDB Integration**: Modern time-series database storage
- **User-Friendly API**: Simple interface for users to record measurements
- **Comprehensive Validation**: Pydantic-based data validation at all boundaries
- **Performance Monitoring**: Built-in logging and performance tracking

## Quick Start

### Prerequisites

- Python 3.12+
- InfluxDB v2.x (optional)

### Installation

**For users** (install from PyPI or source):

```bash
# From PyPI (when published)
pip install metsuperq

# Or from source
git clone https://code.orangeqs.com/opensource/metsuperq.git
```

**For developers** (using [uv](https://docs.astral.sh/uv/)):

```bash
# Install uv if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone and install in development mode
git clone https://code.orangeqs.com/opensource/metsuperq.git
cd metsuperq
uv sync  # Installs all dev dependencies
```

See [Installation Guide](docs/tutorials/installation.md) for detailed setup.

### Basic Usage

```python
from metsuperq.analysis import BaseAnalyzer
from metsuperq.integrations import record_measurement

# Run analysis
analyzer = BaseAnalyzer()
result = analyzer.run_full_analysis("20241008-143022-123-abcdef")

# Record to database
record_measurement(
    analysis_result=result,
    experiment_id="experiment_1",
    device_name="device_1",
    qubit_name="Q1",
)
```

## Development

This project uses [uv](https://docs.astral.sh/uv/) for fast, reproducible dependency management.

```bash
# Install dependencies and set up environment
uv sync

# Run pre-commit hooks
uv run pre-commit install
uv run pre-commit run --all-files

# Run tests
uv run pytest

# Run type checking
uv run pyright
```

See [Contributing Guide](docs/how-to/contributing.md) for details.

## Documentation

- [Installation Guide](docs/tutorials/installation.md)
- [API Reference](docs/reference/)
- [Architecture Overview](docs/explanation/architecture.md)

## Contributing

Fork, create a feature branch, add tests, and submit a PR. See [Contributing Guide](docs/how-to/contributing.md).

## License

BSD 3-Clause License. See [LICENSE](LICENSE) for details.

## Support

- **Documentation**: [Project Docs](https://opensource.orangeqs.info/metsuperq)
- **Issues** and **Discussions**: [GitLab Issues](https://code.orangeqs.com/opensource/metsuperq/-/issues)
- **Merge Requests**: [GitLab Merge Requests](https://code.orangeqs.com/opensource/metsuperq/-/merge_requests)
pyhubo 1.0.3
A python package for resource-efficient quantum optimization
Requires Python: >=3.10

# PyHUBO

**A Python package for resource-efficient quantum optimization**

[![Python](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Version](https://img.shields.io/badge/version-0.2.1-green.svg)](https://pypi.org/project/pyhubo/)

PyHUBO provides an elegant mathematical framework for designing Higher-order Unconstrained Binary Optimization (HUBO) Hamiltonians for combinatorial optimization problems. Unlike traditional QUBO formulations, PyHUBO enables natural representation of complex constraints and objectives through higher-order interactions\.

## Why HUBO over QUBO?

Traditional QUBO (Quadratic Unconstrained Binary Optimization) formulations often require auxiliary variables and penalty methods limiting parameter optimization for example in QAOA, resulting in suboptimal solutions and extensive quantum resources. HUBO models can circumvent these limitations, enabling:

- **Natural problem representation** without penalty terms
- **Reduced quantum resource requirements** through more efficient encodings
- **Direct modeling** of multi-variable constraints and higher-order relationships
- **Seamless integration** with quantum annealers and classical optimization solvers

## Key Features

- **Intuitive Mathematical Interface**: Build optimization problems using natural mathematical expressions
- **Automatic Constraint Handling**: Built-in conflict resolution and validation
- **Flexible Variable Domains**: Support for discrete variables with arbitrary value sets
- **Quantum Integration**: Direct conversion to quantum Hamiltonian representations
- **Multiple Solver Examples**: Openjij and pennylane implementations are shown in [example](#examples) scripts

## Installation

Install PyHUBO from PyPI:

```bash
pip install pyhubo
```

## Examples
We illustrate the usage of Pyhubo on three distinct combinatorial optimization problems:

- [Gate Assignment Problem](./examples/gap.ipynb)
- [Integer Programming](./examples/ip.ipynb)
- [Maximum k-colorable Subgraph Problem](./examples/mkcs.ipynb)

An example for dealing with problems where the domain size is not to the power of two is also given in the [Maximum k-colorable Subgraph Problem](./examples/mkcs.ipynb) script.

## Issues
Please email me (frederik.koch@uni-hamburg.de) in case you spot any issues or if you have any suggestions to improve pyhubo.

## Citation
Citation for this work is provided in the GitHub repository ("About > Cite this repository").
directory-manager 1.0.0
Creating prototypes, managing and visualizing directories.
Requires Python: >=3.12

[![Python Version](https://img.shields.io/badge/python-3.12%2B-darkgreen)](https://www.python.org/) [![License](https://img.shields.io/badge/license-MIT-dc4c21)](LICENSE) [![OS](https://img.shields.io/badge/OS-windows,_linux,_macOS-5cb3e1)](#tests) [![Release](https://img.shields.io/badge/release-1.0.0-3673e1)](#tests)

A pathlib-based python utility tool for directory management  

___

## Purpose

This project was designed as a utility package for larger scaling projects, it serves as an initialization section or as an instance with quick and controlled access to content of files and directories.  

___

## Features

- Fully mapped directory structures by the user
- Quick repository/database setups
- Basic files explorer features for directories and files within the module
- visual mapping for directories as a Tree-map or as a Table

___

## Installation

To install the package, make sure you have [python3](https://www.python.org/downloads/) (version 3.12 and above recommended) and [pip](https://pip.pypa.io/en/stable/installation/) installed in your system, then run the command on the console:

```bash
pip install directory_manager
```

Or clone the repository using [git](https://git-scm.com/install/) and install with the following commands:

```bash
git clone https://github.com/isme2121/directory_manager
cd directory_manager
pip install -e .
```
___

## Usage

Brief use case:

```python
from directory_manager.directory import *

#creating an instance pointing to the current working directory
directory = Directory()

#add sub directories and sub files
directory.add_directories("sub-directory1", "sub-directory2", "sub-directory3")
directory.add_files("file.txt", "sub-directory1/data.json")

#or mirror the cwd in the files system to the instance
directory.image(rewrite=False) #keeping the data we already added with the argument

#returning references to other directories/files
sub_dir1 = directory["sub-directory1"]
if sub_dir1 is not None:
    data = sub_dir1.get_file("data.json")
    data["key"] = "foo"

#all previous execution had no effect on the files system
#populate method is used to update the files system with the instance data
directory.populate(rewrite=False, write_files=True) 
#its important to keep rewrite as False in a sensitive directory
#otherwise it would re-build the entire directory and replace it with the new data

#results:
    .
    ├───file.txt
    ├───sub-directory1
    │   └───data.json
    ├───sub-directory2
    └───sub-directory3
```

___

# CLI commands

**Viewing a directory as a tree**, enter in the command line:

```bash
treeview .
```

or

```bash
treeview path/to/dir
```

**Viewing a directory as a table**, enter in the command line:

```bash
tableview . name type path parent size_kb latime
```

or

```bash
tableview path/to/dir name type path parent size_kb latime
```

To view the different keys for table view, run:
```bash
keysview
```
cynia-agents 2.1.0
A lightweight framework for running generative agents through a Streamlit interface.
Requires Python: >=3.8

![Demo](public/demo.png)

# Cynia Agents

Cynia Agents is a lightweight framework for running generative agents through a Streamlit interface.  
Generation logic lives in installable **components** which can be added or removed without modifying the UI.

The framework provides unified LLM, configuration, and artifact management, allowing agent developers to focus on building components that generate content.

The repository ships with only a simple example component.  Complex generators such as the Bukkit plugin agent can be distributed separately and dropped into the `components` folder.

## Installation

You can install Cynia Agents directly via pip:

```bash
pip install cynia-agents
```

## Usage

### Running the Application

To start the Cynia Agents UI, simply run:

```bash
cynia-agents
```

The application will launch in your default web browser. You can configure your API keys and choose an LLM provider from the **Configuration Center** page in the sidebar.

### Managing Components

You can manage your components in the **Component Center**:
- **Import ZIP**: Upload a ZIP file containing a component.
- **Import Folder**: Select a local folder to import as a component.
- **Dependencies**: Automatically install dependencies for your components.

### Developing Components

To develop a new component, navigate to your component's directory and run:

```bash
cynia-agents dev
```

This command will start the application and temporarily link your current directory as a component, allowing you to see changes in real-time.

See [COMPONENT_DEVELOPMENT.md](COMPONENT_DEVELOPMENT.md) for detailed information on building your own generators.

## Developing Components

A component is a Python module placed inside the `components/` directory. Here's a minimal example of a CyniaAgents component.

```python
from cynia_agents.component_base import BaseComponent

class MyComponent(BaseComponent):
    name = "My Generator"
    description = "Does something amazing"
    # Declare any additional packages your component depends on
    requirements = ["pandas"]

    def render(self):
        import streamlit as st
        self.logger("Rendering my component")
        st.write("Hello from my component")
```

See [COMPONENT_DEVELOPMENT.md](COMPONENT_DEVELOPMENT.md) for information on building your own generators.
Components can be a single Python file or a folder containing multiple files. Single-file components keep their dependencies in a ``requirements`` list while multi-file components include a ``requirements.txt`` file.


## License
Licensed under the Apache 2.0 License.