semvec/pypi-packages huggingface dataset:
mcp-server-jis 1.0.0
MCP Server implementing jis: - The Intent-Centric Web. Bilateral intent DID method where no resolution happens without mutual consent.
Requires Python: >=3.10
Keywords: ai, bilateral-intent, decentralized-identity, did, humotica, intent-centric-web, jis, llm, mcp, provenance, tibet, trust

# mcp-server-jis

[![PyPI](https://img.shields.io/pypi/v/mcp-server-jis.svg)](https://pypi.org/project/mcp-server-jis/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**The Intent-Centric Web: MCP Server for jis: bilateral intent identity.**

> *"The web was built for documents. Then it evolved for applications.
> Now it must evolve for intent — where every interaction begins with 'why'."*

Part of the [HumoticaOS](https://humotica.com) ecosystem.

## What is jis:?

`jis:` is the first DID (Decentralized Identifier) method implementing **bilateral intent verification**. Unlike traditional identity systems where anyone can look up your information, jis: requires **mutual consent** before any identity exchange.

**Traditional DID:**
```
Requester → resolve(did:web:example.com) → DID Document
Anyone can resolve. No consent needed.
```

**jis:**
```
Requester → intent request → Subject accepts → DID Document
No resolution without mutual consent.
```

📄 **Full Specification:** [DOI: 10.5281/zenodo.18374703](https://zenodo.org/records/18374703)

## Installation

```bash
pip install mcp-server-jis
```

## Usage

### With Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "jis": {
      "command": "mcp-server-jis",
      "env": {
        "JIS_IDENTITY": "jis:yourdomain.com:your-id",
        "JIS_SECRET": "your-signing-secret"
      }
    }
  }
}
```

### Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `JIS_IDENTITY` | No | Your jis: identifier |
| `JIS_SECRET` | No | Your signing secret for proofs |
| `HUMOTICA_JIS_ENDPOINT` | No | Custom JIS endpoint (default: humotica.com) |

## Available Tools

### `jis_whoami`
Show your current JIS identity configuration.

### `jis_verify`
Verify a jis: identifier and get public information.

```
jis_verify jis:humotica.com:jasper
```

### `jis_request_intent`
Request bilateral intent from a jis: identity. The core of the Intent-Centric Web.

```
jis_request_intent
  target: jis:humotica.com:jasper
  purpose: authentication
  reason: "Login to my application"
```

### `jis_send_verified`
Send a JIS-verified message with bilateral intent confirmation.

### `ask_humotica`
Ask a verified question to Humotica about TIBET, JIS, or the Intent-Centric Web.

```
ask_humotica "What is bilateral intent?"
```

### `jis_trust_score`
Get the trust score for a jis: identity based on TIBET audit history.

### `jis_spec`
Get information about the jis: specification sections.

## Example Session

```
User: Verify the Humotica founder's identity
ethereum-rlp 0.1.5
Recursive-length prefix (RLP) serialization as used by the Ethereum Specification.
Requires Python: >=3.10

Ethereum RLP
============

Recursive-length prefix (RLP) serialization as used by the [Ethereum Execution Layer Specification (EELS)][eels].

[eels]: https://github.com/ethereum/execution-specs

## Usage

Here's a very basic example demonstrating how to define a schema, then encode/decode it:

```python
from dataclasses import dataclass
from ethereum_rlp import encode, decode_to
from ethereum_types.numeric import Uint
from typing import List

@dataclass
class Stuff:
    toggle: bool
    number: Uint
    sequence: List["Stuff"]

encoded = encode(Stuff(toggle=True, number=Uint(3), sequence=[]))
decoded = decode_to(Stuff, encoded)
assert decoded.number == Uint(3)
```

See the `tests/` directory for more examples.
cfdb-vars 0.1.0
variable definitions for cfdb
Requires Python: >=3.10

# cfdb-vars

<p align="center">
    <em>variable definitions for cfdb</em>
</p>

[![build](https://github.com/mullenkamp/cfdb-vars/workflows/Build/badge.svg)](https://github.com/mullenkamp/cfdb-vars/actions)
[![codecov](https://codecov.io/gh/mullenkamp/cfdb-vars/branch/main/graph/badge.svg)](https://codecov.io/gh/mullenkamp/cfdb-vars)
[![PyPI version](https://badge.fury.io/py/cfdb-vars.svg)](https://badge.fury.io/py/cfdb-vars)

---

**Source Code**: <a href="https://github.com/mullenkamp/cfdb-vars" target="_blank">https://github.com/mullenkamp/cfdb-vars</a>

---
## Overview
The purpose of this package is to separate the variable metadata from the main cfdb package so that additional variables can be added without updating the version of the cfdb package. This package will have the data model for variables defined in msgspec and the variable data defined in python files (one initially).


## Development

### Setup environment

We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build. 

```bash
uv sync
```

### Run unit tests

You can run all the tests with:

```bash
uv run pytest
```

### Format the code

Execute the following commands to apply linting and check typing:

```bash
uv run ruff check .
uv run black --check --diff .
uv run mypy --install-types --non-interactive cfdb_vars
```

To auto-format:

```bash
uv run black .
uv run ruff check --fix .
```

## License

This project is licensed under the terms of the Apache Software License 2.0.
psr-cloud 0.3.19
PSR Cloud Python Module

# psr.cloud (pycloud) Module

## Installation

### From source (Recommended)

Copy `psr` folder and its contents to your work directory or add its parent path to `PYTHONPATH` environment variable before running it.

### pip

If you have pip installed and the correct git credentials run the command:

```python
pip install git+https://github.com/psrenergy/pycloud.git
```

## Usage

```python
import psr.cloud

client = psr.cloud.Client()

case = psr.cloud.Case(data_path=r"C:\PSR\Sddp17.3\Example\12_stages\Case21",
                      price_optimized=True,
                      program="SDDP",
                      program_version="17.3.7",
                      name="Test PyCloud",
                      execution_type="Default",
                      number_of_processes=64,
                      memory_per_process_ratio="2:1",
                      repository_duration=2 # Normal (1 month)
                      )

client.run_case(case)
```

## Authentication

#### Keyword argument specified in `Client` constructor:

- `username` - specify username string
- `password` - plain password string

```python
client = psr.cloud.Client(username="myuser", password=os.environ["MY_PASSWORD"])
```

The password will never be stored plainly, only its md5 hash will be used.

#### Read from environment variables

Prefered over keyword arguments:

- `PSR_CLOUD_USER` - specify username
- `PSR_CLOUD_PASSWORD_HASH` - md5 password hash

Password hash can be obtained by running the code below:

```python
import psr.cloud as pycloud
pycloud.hash_password("ExamplePassword")
```


#### Automatic

Will use PSR Cloud client auth data, if avaiblable.

## Querying PSR Cloud options

#### Available programs/models

```python
get_programs() -> list[str]
```

#### Available model versions

```python
get_program_versions(program: str) -> dict[int, str]
```

#### Available execution types

```python
get_execution_types(program: str, version: Union[str, int]) -> dict[int, str]
```

#### Available memory per process ratios

```python
get_memory_per_process_ratios() -> list[str]
```

#### Available repository durations

```python
get_repository_durations() -> dict[int, str]
```