semvec/pypi-packages huggingface dataset:
ommx-python-mip-adapter 2.3.5
An adapter for the Python-MIP from/to OMMX.
Requires Python: >=3.10

OMMX adapter for Python-MIP
============================
[![PyPI - Version](https://img.shields.io/pypi/v/ommx-python-mip-adapter)](https://pypi.org/project/ommx-python-mip-adapter/)

This package provides an adapter for the [Python-MIP](https://www.python-mip.com/) from/to [OMMX](https://github.com/Jij-Inc/ommx)

Python-MIP as a solver in OMMX toolchain
-----------------------------------------
```mermaid
sequenceDiagram
    participant U as User
    participant A as Adapter
    participant P as Python-MIP
    U->>A: ommx.v1.Instance
    A->>U: Python-MIP model
    U->>P: Python-MIP model and Parameters for Python-MIP;
    P->>P: Solve with CBC, Gurobi, or other solvers
    P->>U: Optimized model
    U->>A: Optimized model and ommx.v1.Instance
    A->>U: ommx.v1.Solution
```

Python-MIP as a user interface to create OMMX instance
-------------------------------------------------------
```mermaid
sequenceDiagram
    participant U as User
    participant A as Adapter
    participant O as Other OMMX toolchain
    U->>A: Python-MIP model
    A->>U: ommx.v1.Instance
    U->>O: ommx.v1.Instance and Parameters for other solver
    O->>O: Solve the instance with other solver using other adapter
    O->>U: ommx.v1.Solution
```

Usage
======
`ommx-python-mip-adapter` can be installed from PyPI as follows:

```bash
pip install ommx-python-mip-adapter
```

Python-MIP can be used through `ommx-python-mip-adapter` by using the following:

```python markdown-code-runner
from ommx_python_mip_adapter import OMMXPythonMIPAdapter
from ommx.v1 import Instance, DecisionVariable

x1 = DecisionVariable.integer(1, lower=0, upper=5)
ommx_instance = Instance.from_components(
    decision_variables=[x1],
    objective=x1,
    constraints=[],
    sense=Instance.MINIMIZE,
)

# Create `ommx.v1.Solution` from the `mip.Model`
ommx_solution = OMMXPythonMIPAdapter.solve(ommx_instance)

print(ommx_solution)
```

You can get `ommx.v1.Instance` from a Python-MIP model as the following:

```python markdown-code-runner
import mip
import ommx_python_mip_adapter as adapter

model = mip.Model()
x1=model.add_var(name="1", var_type=mip.INTEGER, lb=0, ub=5)
x2=model.add_var(name="2", var_type=mip.CONTINUOUS, lb=0, ub=5)
model.objective = - x1 - 2 * x2
model.add_constr(x1 + x2 - 6 <= 0)

ommx_instance = adapter.model_to_instance(model)

print(ommx_instance)
```

Reference
==============
- [OMMX-Python-MIP-Adapter API Reference](https://jij-inc.github.io/ommx-python-mip-adapter/index.html)
ommx-pyscipopt-adapter 2.3.5
An adapter for the SCIP from OMMX.
Requires Python: <3.14,>=3.10

# OMMX adapter for SCIP

This package provides an adapter for the [SCIP](https://www.scipopt.org/) from [OMMX](https://github.com/Jij-Inc/ommx)

## Usage

`ommx-pyscipopt-adapter` can be installed from PyPI as follows:

```bash
pip install ommx-pyscipopt-adapter
```

SCIP can be used through `ommx-pyscipopt-adapter` by using the following:

```python markdown-code-runner
from ommx_pyscipopt_adapter import OMMXPySCIPOptAdapter
from ommx.v1 import Instance, DecisionVariable

x1 = DecisionVariable.integer(1, lower=0, upper=5)
ommx_instance = Instance.from_components(
    decision_variables=[x1],
    objective=x1,
    constraints=[],
    sense=Instance.MINIMIZE,
)

# Create `ommx.v1.Solution` from the `pyscipot.Model`
ommx_solution = OMMXPySCIPOptAdapter.solve(ommx_instance)

print(ommx_solution)
```

## Reference

TBW
ommx-highs-adapter 2.3.5
An adapter between OMMX and HiGHS
Requires Python: <3.14,>=3.10

# ommx-highs-adapter

Provides an adapter to translate between [OMMX](https://github.com/Jij-Inc/ommx) and [HiGHS](https://highs.dev)

# Usage

`ommx-highs-adapter` can be installed from PyPI as follows:

```bash
pip install ommx-highs-adapter
```

An example usage of HiGHS through this adapter:

```python markdown-code-runner
from ommx_highs_adapter import OMMXHighsAdapter
from ommx.v1 import Instance, DecisionVariable

x1 = DecisionVariable.integer(1, lower=0, upper=5)
ommx_instance = Instance.from_components(
    decision_variables=[x1],
    objective=x1,
    constraints=[],
    sense=Instance.MINIMIZE,
)

# Create `ommx.v1.Solution` through `highspy.Highs`
ommx_solution = OMMXHighsAdapter.solve(ommx_instance)

print(ommx_solution)
```
aqpxlib 0.1.1
Acute Protocol Exerciser Python Libraries
Requires Python: >=3.10
Keywords: development

# Acute Protocol Exerciser Python Libraries (AQPXLIB)

[![License](https://img.shields.io/badge/License-BSD_3--Clause-orange.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![PyPI](https://img.shields.io/pypi/v/aqpxlib)](https://pypi.org/project/aqpxlib/)

The **Protocol Exerciser Library** is a friendly interface to interact with Acute's Protocol Exerciser instruments. 

The key features are:

  * **Friendly**: The library is fully written in Python with comprehensive type hints.
  * **Intuitive**: Actions initiated by these simulated devices are just like real ones.
  * **Easy to use**: Designed to be easy to use and integrate into your own projects.

## Supported series

| Type | Product Series |
| ---- | -------------- |
| Protocol Exerciser | [PX2816B](https://www.acute.com.tw/) |
iflow-mcp_bingal-fastdomaincheck-mcp-server 0.1.12
MCP Server for checking domain name availability using WHOIS and DNS via stdio.
Requires Python: >=3.11
Keywords: mcp, domain, whois, dns, availability, check, stdio

# FastDomainCheck MCP Server (Python)

This is a domain availability check server implemented using Python and the Model Context Protocol (MCP).
It provides MCP Tools to check if single or multiple domain names are already registered.


## Features

- Bulk domain registration status checking
- Dual verification using WHOIS and DNS
- Support for IDN (Internationalized Domain Names)
- Concise output format
- Built-in input validation and error handling

## Tool Documentation

### check_domains

Check registration status for multiple domain names.

#### Input Format

```json
{
  "domains": ["example.com", "test.com"]
}
```

Parameters:
- `domains`: Array of strings containing domain names to check
  - Maximum length of 255 characters per domain
  - Maximum 50 domains per request
  - No empty domain names allowed

#### Output Format

```json
{
  "results": {
    "example.com": {
      "registered": true
    },
    "test.com": {
      "registered": false
    }
  }
}
```

Response Fields:
- `results`: Object with domain names as keys and check results as values
  - `registered`: Boolean
    - `true`: Domain is registered
    - `false`: Domain is available

#### Error Handling

The tool will return an error in the following cases:
1. Empty domains list
2. More than 50 domains in request
3. Empty domain name
4. Domain name exceeding 255 characters
5. Result serialization failure

Error Response Format:
```json
{
  "error": "Error: domains list cannot be empty"
}
```

#### Usage Examples

Check multiple domains:
> Request
```json
{
  "domains": ["example.com", "test123456.com"]
}
```

> Response
```json
{
  "results": {
    "example.com": {
      "registered": true
    },
    "test123456.com": {
      "registered": false
    }
  }
}
```


## MCP Server Settings

#### Configuring FastDomainCheck MCP in Claude Deskto
Modify your claude-desktop-config.json file as shown below

```json
{
  "mcpServers": {
    "fastdomaincheck": {
      "command": "uvx",
      "args": [
        "fastdomaincheck-mcp-server"
      ]
    }
  }
}
```



## Go Version Reference


[go version](https://github.com/bingal/FastDomainCheck-MCP-Server)

## Contributing

Feel free to open issues or submit pull requests.

## License

[MIT License](LICENSE) *(You should add a LICENSE file, typically containing the MIT license text)*