semvec/pypi-packages huggingface dataset:
ipython-kernel-executor 0.1.1
A lightweight Python package to execute code in an isolated IPython kernel and capture results, stdout, and stderr.
Requires Python: >=2

# IPython Kernel Executor

A lightweight Python package to execute code in an isolated IPython kernel and capture results, stdout, and stderr.

Supports Python 2+.

## **Installation**

Make sure you have `jupyter-client` and `ipykernel` installed:

```bash
pip install jupyter-client ipykernel
```

Then, install this package:

```bash
pip install ipython-kernel-executor
```

## **Usage**

### **Basic Execution**

```python
from __future__ import print_function

from ipython_kernel_executor import IPythonKernelExecutor

with IPythonKernelExecutor() as executor:
    # Captures result
    result, stdout, stderr = executor("1 + 1")
    print(repr(result))  # '2'
    print(repr(stdout))  # ''
    print(repr(stderr))  # ''

    # Captures stdout
    result, stdout, stderr = executor("print('Hello, World!')")
    print(repr(result))  # ''
    print(repr(stdout))  # 'Hello, World!\n'
    print(repr(stderr))  # ''

    # Captures stderr
    result, stdout, stderr = executor("1 / 0")
    print(repr(result))  # ''
    print(repr(stdout))  # ''
    print(repr(stderr))  # contains 'ZeroDivisionError'
```

### **Manual Shutdown (Optional)**

If not using `with`, manually shut down the kernel:

```python
executor = IPythonKernelExecutor()
result, stdout, stderr = executor("2 * 3")
executor.shutdown()  # Clean up
```

## Contributing

Contributions are welcome!  Please submit pull requests or open issues on GitHub.

## License

This project is licensed under the [MIT License](LICENSE). See the [LICENSE](LICENSE) file for details.
rai-sim 0.0.2
Package to run simulations
Requires Python: <3.13,>=3.10

## RAI Sim

## Description

The RAI Sim is a package providing interface to implement connection with a specific simulation.

### Components

-   `SimulationBridge` - An interface for connecting with a specific simulation. It manages scene setup, spawning, despawning objects, getting current state of the scene.

-   `SimulationConfig` - base config class to specify the entities to be spawned. For each simulation bridge there should be specified custom simulation config specifying additional parameters needed to run and connect with the simulation.

-   `SceneState` - stores the current info about spawned entities

### Example implementation

-   `O3DExROS2Bridge` - An implementation of SimulationBridge for working with simulation based on O3DE and ROS2.
-   `O3DExROS2SimulationConfig` - config class for `O3DExROS2Bridge`
get-chrome-paths 0.1.1
A cross-platform Python utility to find Chromium-based browser executable paths on Windows, macOS, and Linux.
Requires Python: >=2

# Get Chrome Paths

A cross-platform Python utility to find Chromium-based browser executable paths on Windows, macOS, and Linux.

Supports Python 2+.

## Features

- Detects installed Chrome, Chromium, and Microsoft Edge browsers
- Supports Windows (common registry path lookup), macOS (common application paths), and Linux (common installation paths)

## Installation

```bash
pip install get-chrome-paths
```

## Usage

```python
from __future__ import print_function

from get_chrome_paths import get_chrome_paths

# Get all available Chrome/Chromium-based browser paths
for path in get_chrome_paths():
    print(path)
# Example output on Windows:
# C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe
# C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe
```

You can also run as a module:

```bash
python -m get_chrome_paths
# Example output on Windows:
# C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe
# C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe
```

## Contributing

Contributions are welcome! Please open an issue or submit a pull request for any improvements.

## License

MIT License. See [LICENSE](LICENSE) for more information.
pddlsim 0.2.0.dev3
PDDL-based simulator for the BIU course "Introduction to Intelligent, Knowledge-Based and Cognitive Systems"
Requires Python: >=3.12
Keywords: PDDL, agent, simulator

<div align=center>
    <picture>
        <source srcset="https://raw.githubusercontent.com/galk-research/pddlsim/refs/heads/main/assets/logo/pddlsim-dark.svg" media="(prefers-color-scheme: dark)"/>
        <img alt="PDDLSIM logo" src="https://raw.githubusercontent.com/galk-research/pddlsim/refs/heads/main/assets/logo/pddlsim-light.svg"/>
    </picture>
    <hr/>
</div>

PDDLSIM is an execution simulator for PDDL domain-problem pairs, with a supporting library to define agents that interface with said simulator. This can happen locally, or via a remote, internet connection.

PDDLSIM is designed to allow the evaluation of sequential action-selection algorithms across a wide variety of tasks and environments, and was created for the Bar-Ilan University course ["Introduction to Intelligent, Cognitive, and Knowledge-Based Systems" (89-674)](https://www.cs.biu.ac.il/~galk/teach/current/intsys/). In the course, it is used as a part of the final project.

The simulator is run with PDDL domain and problem files. An agent can then connect to the simulator and interact with it: requesting the domain-problem pair definition, and then attempting to solve the task by selecting actions and sending them to the simulator for execution. The simulator will report the number of actions taken, whether the goal of the task was achieved, the wall-clock time taken, etc. The PDDL description received by the agent may be partially redacted. For example, it might not receive information about action success probabilities, or some objects may remain hidden until the agent reaches a specific state, etc.

## Documentation

The documentation is maintained in the [PDDLSIM wiki](https://github.com/galk-research/pddlsim/wiki). To start, see [the tutorial](https://github.com/galk-research/pddlsim/wiki/Tutorial). The documentation also includes usage guidelines, information about creating agents that interact with the simulator, and more.

Beyond the wiki, PDDLSIM also has an [online API reference](https://galk-research.github.io/pddlsim).

## Installation

PDDLSIM is available on [PyPI](https://pypi.org/project/pddlsim/), requiring no external dependencies. PDDLSIM requires Python 3.12 or later. Earlier, legacy versions of PDDLSIM are also available on PyPI, but these have a vastly different API than current PDDLSIM, and are unsupported, as these use Python 2.7.

To install PDDLSIM using `pip`, run:

```bash
pip install pddlsim
```

Check out [`examples/`](https://github.com/galk-research/pddlsim/tree/main/examples/) for some examples of using PDDLSIM, for creating agents that interface with simulators, running simulators that interface with agents, etc.

## Contributing

For a step-by-step guide to contributing to PDDLSIM, see the [Contributing](https://github.com/galk-research/pddlsim/wiki/Contributing/) page.
turn-python 1.0.0
A python package for the Turn.io WhatsApp API
Requires Python: >=3.6

# turn-python

## Documentation Links
- [Turn API documentation](https://whatsapp.turn.io/docs/index.html)
- [WhatsApp Business API](https://developers.facebook.com/docs/whatsapp)

## Usage

1. Get an API token from [Turn](https://app.turn.io/) (currently only tokens are supported, not username / passwords)

1. Add this as an environment variable, or pass in to the turn client

    ``` bash
    $ export TURN_AUTH_TOKEN={your token}
    ```

1. Usage

    ``` python
    from turn import TurnClient
    
    turn_client = TurnClient(token={optionally add your token here})

    # Get a user's whatsapp id
    wa_id = turn_client.contacts.get_whatsapp_id('123456')

    # Send a message
    turn_client.messages.send_text(wa_id, 'Hello')
   
    # Send a media file
    with open("example.jpg", "rb") as file:
        turn_client.messages.send_media(
            whatsapp_id=wa_id,
            file=file,
            content_type="image/jpeg",
            media_type="image",
            caption="Here’s an image"
        )
    ```