semvec/pypi-packages huggingface dataset:
mcp-server-jl 0.1.8
Joblogic MCP server using stdio transport
Requires Python: >=3.12

# Joblogic MCP Server

This project implements an MCP (Model Context Protocol) server using stdio transport for communication. It provides tools for test case generation and formatting, along with other utilities for Joblogic documentation and API specifications.

## Installation

You can install the package directly from PyPI:

```bash
pip install mcp-server-jl
```

Or install it from the source code:

```bash
pip install .
```

## Usage

### Command Line

After installation, you can run the MCP server directly from the command line:

```bash
mcp-server-jl
```

### As a Python Package

```python
from mcp_server_jl.server import mcp, run_server
import anyio

# Add your custom tools
@mcp.tool()
def my_custom_tool():
    # Your code here
    pass

# Run the server
if __name__ == "__main__":
    anyio.run(run_server)
```

## Available Tools

### Generate Test Cases

Generates test cases from a markdown specification:

```python
result = await mcp.generate_testcases_for_content_spec(markdown_content, spec_file_path)
```

### Format Test Cases

Format and clean test case files:

```python
result = await mcp.format_all_testcases(input_folder, output_folder)
```

### Convert to Markdown

Convert a resource to markdown:

```python
markdown = await mcp.convert_to_markdown(uri)
```

## Docker

You can also run the server using Docker:

```bash
docker build -t mcp-local/joblogic .
docker run -it mcp-local/joblogic
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
cotwo 1.2.0
Simple visualizer for molecules and isosurfaces with Plotly
Requires Python: >=3.11

cotwo
=====

(like, carbon dioxide)

Render molecules with Plotly.

Installation
------------

```sh
pip install cotwo
```

or

```sh
uv add cotwo
```

Features
--------

+ Read and display structures from XYZ files
+ Read and display structures from SMILES strings
+ Plot smooth isosurfaces from cube files

Usage
-----

Use the "Molecule" class to instanciate an object from either an XYZ file (give the path) or a SMILES string:

```py
from cotwo import Molecule

# From an XYZ file
methane = Molecule.from_file("methane.xyz")

# From an output file
ethanol = Molecule.from_file("ethanol.out")

# From a SMILES string
caffeine = Molecule.from_smiles("CN1C=NC2=C1C(=O)N(C(=O)N2C)C")
```

```python
# Display a basic 3D visualization of the molecule
caffeine.show()

# Create a Plotly figure
fig = caffeine.create_fig()
```

The `Molecule` class can visualize molecular orbitals and spin densities by generating and displaying isosurfaces:

```python
# First, create the cube file for a specific molecular orbital
# (requires orca_plot to be installed)
mo_file = molecule.create_molecular_orbital("calculation.gbw", 42)  # HOMO orbital, for example

# Display the molecule with the molecular orbital isosurface
molecule.show_with_isosurface(
    mo_file,
    isovalue=0.03,  # Adjust the isosurface threshold
    colors=("#FF4081", "#1E88E5"),  # Custom colors for positive/negative phases
)
```

```python
# Load a molecule from an optimization calculation output
optimized = Molecule.from_file("optimized.xyz")

# Generate and visualize the HOMO-LUMO gap
homo_file = optimized.create_molecular_orbital("calculation.gbw", "42a")  # HOMO
lumo_file = optimized.create_molecular_orbital("calculation.gbw", "43a")  # LUMO

# View HOMO
optimized.show_with_isosurface(homo_file, colors=("#FF4081", "#1E88E5"))

# View LUMO
optimized.show_with_isosurface(lumo_file, colors=("#FF9800", "#2979FF"))
```


Roadmap
-------

Since creating the meshes and the isosurfaces is computationally heavy,
a neat feature would be the possibility to precompute several isosurfaces and keep them in memory.
This way multiple densities can be inspected in short succession without the computational overhead.

In the same vein, it would be cool to load a directory and then be able to select from the available `.cube` files. One could also compute the verticies and faces of the isosurfaces and store
them separately, then loading would be much faster.
That said, it's kind of beyond the scope of this project - best to keep it lightweigth and focused
on only the actual rendering.