semvec/pypi-packages huggingface dataset:
tide-sim 0.2.0
A package for adding a simulation environment to a tide robot
License: MIT
Requires Python: >=3.12
Keywords: pybullet, robotics, simulation, tide

# Tide Simulation

A Python package for adding a simulation environment to a tide robot using PyBullet. This package provides a simulation node that can be used to simulate robot behavior in a physics environment.

## Features

- PyBullet-based physics simulation
- Real-time robot joint control
- Integration with tide robot framework
- Support for custom URDF models
- Configurable simulation parameters

## Installation

### From GitHub

You can install the package directly from GitHub using pip:

```bash
pip install git+https://github.com/schreiaj/tide-sim.git
```

Or with uv:

```bash
uv pip install git+https://github.com/schreiaj/tide-sim.git
```


## Usage

The package provides a `SimulationNode` class that can be used to simulate robot behavior:

It can be used like any other node in your tide project

```
- type: tide_sim.SimulationNode
    params:
      robot_id: "simbot"
      sim_rate: 60
      update_rate: 20
```
### Configuration Options

- `robot_id`: Identifier for the robot (default: "simbot")
- `headless`: Run simulation without GUI (default: False)
- `sim_rate`: Physics simulation rate in Hz (default: 240)
- `update_rate`: Rate at which pose updates will be published
- `urdf_path`: Path to the robot's URDF file (default: "assets/simulation/robot.urdf")

### Joint Control

The simulation node subscribes to joint state commands and applies them to the simulated robot:

It uses the joint names from the URDF file. If positions are specified it will use a position controller with velocity and effort constraints. If no position but a velocity it will use a velocity controller with effort constraints. If no position or velocity it will use a torque controller. 

It is criticl that all arrays are the same length. This may be enforced in the future but for now it will just cause runtime errors. 

```python
from tide_sim import JointState

# Create a joint state command
joint_state = JointState(
    name=["joint1", "joint2"],
    position=[0.0, 1.57],  # in radians
    velocity=[],   # in rad/s
    effort=[]      # in N⋅m
)

# The simulation node will automatically apply these joint states
```

### Development 

For development, clone the repository and install in editable mode:

```bash
# Clone the repository
git clone https://github.com/schreiaj/tide-sim.git
cd tide-sim

# Create virtual environment and install dependencies
make install

# Install pre-commit hooks (optional but recommended)
pip install pre-commit
pre-commit install
```


The project uses several development tools:
- `black` for code formatting
- `isort` for import sorting
- `ruff` for linting
- `mypy` for type checking
- `pytest` for testing

To run the development tools:
```bash
make test     # Run tests
make lint     # Run linters
make format   # Format code
make clean    # Clean up build artifacts
```

## Dependencies

- `pybullet>=3.2.7`: Physics simulation engine
- `tide-sdk>=0.1.5`: Tide robot framework integration

## License

MIT License
alumath-peergroup-6 1.0.0
A Python library for matrix multiplication with support for different dimensions
License: MIT
Requires Python: >=3.7
Keywords: matrix multiplication linear algebra mathematics

# alumath_peergroup_6

A comprehensive Python library for matrix multiplication with support for different dimensions and broadcasting.

## Features

- **Standard Matrix Multiplication**: Classic A × B multiplication
- **Element-wise Multiplication**: Hadamard product for same-dimension matrices
- **Broadcasting Support**: Intelligent dimension handling for compatible matrices
- **Comprehensive Error Handling**: Clear error messages for invalid operations
- **Pure Python**: No external dependencies required
- **Type Hints**: Full type annotation support
- **Extensive Documentation**: Complete API documentation and examples

## Installation

\`\`\`bash
pip install alumath_peergroup_6
\`\`\`

## Quick Start

```python
from alumath_peergroup_6 import Matrix, multiply

# Create matrices
matrix_a = Matrix([[1, 2], [3, 4]])
matrix_b = Matrix([[5, 6], [7, 8]])

# Standard matrix multiplication
result = multiply(matrix_a, matrix_b, method="standard")
print(result)

# Element-wise multiplication
result = multiply(matrix_a, matrix_b, method="hadamard")
print(result)

# Broadcasting multiplication
scalar = Matrix([[2]])
result = multiply(matrix_a, scalar, method="broadcast")
print(result)
fq-test-release 0.8.0
A custom wrapper for the OpenAI Python package with modified response handling
License: MIT
Requires Python: >=3.8
Keywords: openai, wrapper, api, chatgpt

# custom-openai

A robust, user-friendly wrapper for the OpenAI Python package, featuring simplified response formatting and explicit error handling.

## Features

* **Clean and consistent responses**: Always get predictable output from your completions.
* **Automatic error handling**: Exceptions are caught and returned in a structured way.
* **Async and sync support**: Use the API in both synchronous and asynchronous Python projects.

## Installation

```bash
pip install custom-openai
```

## Usage

### Synchronous

```python
from custom_openai import CustomOpenAIClient

client = CustomOpenAIClient(api_key="your-api-key")
response = client.chat_completions_create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello!"}],
    max_tokens=100
)
if response["success"]:
    print(response["content"])
else:
    print("Error:", response["error_type"], response["error_message"])
```

### Asynchronous

```python
import asyncio
from custom_openai import CustomAsyncOpenAIClient

async def main():
    client = CustomAsyncOpenAIClient(api_key="your-api-key")
    response = await client.chat_completions_create(
        model="gpt-4",
        messages=[{"role": "user", "content": "Hello!"}],
        max_tokens=100
    )
    if response["success"]:
        print(response["content"])
    else:
        print("Error:", response["error_type"], response["error_message"])

asyncio.run(main())
```

## Response Format

All responses follow the same structure:

```python
{
    "success": True, # or False if there was an error
    "text": "...", # model output (only if success)
    "model": "...", # model used
    "usage": {
        "prompt_tokens": ...,
        "completion_tokens": ...,
        "total_tokens": ...
    },
    "finish_reason": "...", # reason for completion
    # Error fields (only present if success is False):
    "error_type": "...",
    "error_message": "..."
}
```

## License

MIT License