semvec/pypi-packages huggingface dataset:
rustgression 0.4.1
Fast OLS and TLS regression using Rust backend
Requires Python: >=3.11

# rustgression

[![PyPI Downloads](https://static.pepy.tech/badge/rustgression)](https://pepy.tech/projects/rustgression)

This project provides fast regression analysis (OLS, TLS) as a Python package.

- **WebSite**: <https://pypi.org/project/rustgression/>
- **Documentation**: <https://github.com/connect0459/rustgression/blob/main/README.md>
- **Source code**: <https://github.com/connect0459/rustgression>
- **Bug reports and security issues**: <https://github.com/connect0459/rustgression/issues>

## Overview

`rustgression` provides high-performance regression analysis tools implemented in Rust as a Python package.
It includes the following features.

- **Ordinary Least Squares (OLS)**: Traditional least squares method. Minimizes errors only in the y-direction.
- **Total Least Squares (TLS)**: Orthogonal regression. Considers errors in both variables (x-axis and y-axis).

This package targets Python version `3.11` and above.

## Installation

```bash
pip install rustgression
```

## Usage

```python
import numpy as np
from rustgression import OlsRegressor, TlsRegressor

def generate_sample_data(size: int = 100, noise_std: float = 0.5) -> tuple[np.ndarray, np.ndarray]:
    """Generate sample data for regression example.

    Args:
        size: Number of data points
        noise_std: Standard deviation of noise

    Returns:
        Tuple of (x, y) arrays
    """
    x = np.linspace(0, 10, size)
    true_slope, true_intercept = 2.0, 1.0
    y = true_slope * x + true_intercept + np.random.normal(0, noise_std, size)
    return x, y

def main():
    # Generate sample data
    x, y = generate_sample_data()

    # Ordinary Least Squares (OLS) Regression
    print("=== Ordinary Least Squares (OLS) Results ===")
    ols_model = OlsRegressor(x, y)
    print(f"Slope: {ols_model.slope():.4f}")
    print(f"Intercept: {ols_model.intercept():.4f}")
    print(f"R-value: {ols_model.r_value():.4f}")
    print(f"P-value: {ols_model.p_value():.4e}")
    print(f"Standard Error: {ols_model.stderr():.4f}")
    print(f"Intercept Standard Error: {ols_model.intercept_stderr():.4f}\n")

    # Total Least Squares (TLS) Regression
    print("=== Total Least Squares (TLS) Results ===")
    tls_model = TlsRegressor(x, y)
    print(f"Slope: {tls_model.slope():.4f}")
    print(f"Intercept: {tls_model.intercept():.4f}")
    print(f"R-value: {tls_model.r_value():.4f}")

if __name__ == "__main__":
    main()
```

## Documentation

For detailed documentation in your preferred language.

- **🇺🇸 [English Documentation](docs/en/README.md)**
- **🇯🇵 [日本語ドキュメント](docs/ja/README.md)**

For developers and contributors.

- **🔧 [Developer Documentation (English)](docs/en/development.md)**
- **🔧 [開発者ドキュメント（日本語）](docs/ja/development.md)**

## Author

[connect0459](https://github.com/connect0459)
iflow-mcp_hk_transportation_mcp_server 0.3.0
Hong Kong transportation MCP Server providing transportation data tools
Requires Python: >=3.7

# Hong Kong transportation Data MCP Server

[![GitHub Repository](https://img.shields.io/badge/GitHub-Repository-blue.svg)](https://github.com/hkopenai/hk-transportation-mcp-server)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

This is an MCP server that provides access to transportation related data in Hong Kong through a FastMCP interface.

## Features

### Passenger Traffic Statistics
- Get daily passenger traffic statistics at Hong Kong control points. Filter data by date ranges. Breakdown statistics by visitor types (Hong Kong Residents, Mainland Visitors, Other Visitors)

### Real time Arrival Data of Kowloon Motor Bus and Long Win Bus Services
- Get all bus routes of Kowloon Motor Bus (KMB) and Long Win Bus Services. Filter by language (English, Traditional Chinese, Simplified Chinese)

### Land Boundary Control Points Waiting Times
- Fetch current waiting times at land boundary control points in Hong Kong. Filter by language (English, Traditional Chinese, Simplified Chinese)

## Data Source

- Passenger traffic data from Hong Kong Immigration Department
- Bus route data from Kowloon Motor Bus and Long Win Bus Services

## Examples

* How many hong kong arrival yesterday through high speed railway.
* Get all KMB/LWB bus routes in Traditional Chinese.
* What are the current waiting times at Hong Kong land boundary control points?

## Setup

1. Clone this repository
2. Install Python dependencies:
   ```bash
   pip install -r requirements.txt
   ```
3. Run the server:
   ```bash
   python server.py
   ```

### Running Options

- Default stdio mode: `python server.py`
- SSE mode (port 8000): `python server.py --sse`

## Cline Integration

To connect this MCP server to Cline using stdio:

1. Add this configuration to your Cline MCP settings (cline_mcp_settings.json):
```json
{
  "hk-transportation": {
    "disabled": false,
    "timeout": 3,
    "type": "stdio",
    "command": "uvx",
    "args": [
      "hkopenai.hk-transportation-mcp-server"
    ]
  }
}
```

## Testing

Tests are available in the `tests/` directory. Run with:
```bash
pytest
```
xrscipy 3.1.0
Scipy integrated into xarray
Requires Python: <4,>=3.9

[![Documentation Status](https://readthedocs.org/projects/xr-scipy/badge/?version=latest)](http://xr-scipy.readthedocs.io/en/latest/?badge=latest)

# scipy for xarray

xr-scipy is a thin wrapper of scipy for the [xarray](https://docs.xarray.dev) eco-system. You can read the documentation [here](https://xr-scipy.readthedocs.io).

Many scipy functions, such as `scipy.integrate.trapezoid` requires coordinate array as an argument.
xr-scipy wraps these functions to use native coordinate objects of xarray and returns an xarray object with the computed data.
This enables more xarray-oriented data analysis with scipy.

Other usage/options are kept almost the same as the original scipy function.

# Example

```python
import xarray as xr
import numpy as np
import xrscipy.integrate

In[1]: da = xr.DataArray([0, 3, 2, 4, 6], coords={'x': np.linspace(0, 1, 5)})
In[2]: da
Out[2]:
<xarray.DataArray (x: 5)>
array([0, 3, 2, 4, 6])
Coordinates:
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

In[3]: xrscipy.integrate.cumulative_trapezoid(da, coord='x')
Out[3]:
<xarray.DataArray (x: 5)>
array([0.   , 0.375, 1.   , 1.75 , 3.   ])
Coordinates:
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0
```

# Installation

`pip install xrscipy`