semvec/pypi-packages huggingface dataset:
katsuba 0.4.0
Python bindings to the katsuba Rust libraries

# Katsuba

Python bindings to the [Katsuba](https://github.com/vbe0201/katsuba) libraries.

## Error handling

Most errors are represented either as native Python exceptions where it makes
sense, or as a `katsuba.KatsubaError` for custom errors from the Rust side.

## Bindings

### `katsuba.op`

Bindings to core functionality from the `katsuba-object-property` crate.

```py
from katsuba.op import *
from katsuba.utils import string_id

# Open a type list from file system
type_list = TypeList.open("types.json")

# Configure serializer options
opts = SerializerOptions()
opts.flags |= STATEFUL_FLAGS
opts.shallow = False

# Construct the serializer
ser = Serializer(opts, type_list)

# Deserialize a file
with open("TemplateManifest.xml", "rb") as f:
    manifest = f.read()
    assert manifest[:4] == b"BINd"

manifest = ser.deserialize(manifest[4:])

# Make sure we deserialized the right object:
assert manifest.type_hash == string_id("class TemplateManifest")

# Iterate the templates in the resulting object:
for location in manifest["m_serializedTemplates"]:
    print(f"Template {location['m_id']} at {location['m_filename']}")
```

### `katsuba.wad`

Bindings to core functionality from the `katsuba-wad` crate.

```py
from katsuba.op import Serializer
from katsuba.wad import Archive

# See `katsuba.op` above.
s = Serializer(...)

# Open an archive memory-mapped:
a = Archive.mmap("/path/to/Root.wad")

print(f"{len(a)} files in archive!")

# Deserialize a file out of the given archive:
if "TemplateManifest.xml" in a:
    a.deserialize("TemplateManifest.xml", s)

# Iterate over files in the archive and get their contents:
for path in a:
    data = a[path]

# With a glob pattern for filtering files:
for path in a.iter_glob("ObjectData/**/*.xml"):
    data = a[path]
```

### `katsuba.utils`

Bindings to useful components from the `katsuba-utils` crate.

For the time being, this features the hash functions `djb2` and `string_id`.
package-creation-mahdiznaidi 0.1.0
TP4 - Package Python complet avec tests, lint, docs et CI.
Requires Python: <3.13,>=3.11

# TP4 - Package Python (Poetry, Tests, Docs, CI)

Projet réalisé en suivant le tutoriel **"Build Python Package"**.

## Objectif

Construire un package Python complet avec :

- structure `src/`
- tests unitaires (`pytest`, `pytest-cov`)
- lint/format (`ruff`) + hooks `pre-commit`
- documentation Sphinx
- workflows GitHub Actions (tests + déploiement docs)
- préparation à la publication PyPI

## Arborescence

```text
.
├── .github/workflows/
│   ├── sphinx_doc.yaml
│   └── tests.yaml
├── docs/
│   ├── _static/
│   ├── _templates/
│   ├── Makefile
│   ├── conf.py
│   ├── index.rst
│   ├── make.bat
│   └── modules.rst
├── src/package_creation_tutorial/
│   ├── __init__.py
│   ├── main.py
│   └── string_ops.py
├── tests/
│   └── test_string_ops.py
├── .gitignore
├── .pre-commit-config.yaml
├── main.py
├── pyproject.toml
└── README.md
```

## Prérequis

- Python 3.11+ (3.12 recommandé)
- Poetry
- Git

Installation de Poetry (exemple avec `pipx`) :

```bash
pipx install poetry
```

## 1) Build local du package

```bash
poetry install --with dev
poetry build
poetry run python main.py
```

Le script affiche :

- la chaîne originale
- sa version inversée
- le nombre de voyelles
- la chaîne avec capitalisation par mot

## 2) Tests et couverture

```bash
poetry run pytest
poetry run pytest --cov src/
```

## 3) Git / GitHub (rappel)

```bash
git init
git add .
git commit -m "initial project setup"
git remote add origin <URL_DU_REPO>
git push -u origin main
```

## 4) Ruff + pre-commit

```bash
poetry run ruff check --fix .
poetry run pre-commit install
poetry run pre-commit run --all-files
```

Configuration : `.pre-commit-config.yaml` avec hook `ruff`.

## 5) Documentation Sphinx

Build local :

```bash
cd docs
make html
```

Sous Windows :

```powershell
cd docs
.\make.bat html
```

Fichier généré :

- `docs/build/html/index.html`

## 6) GitHub Actions

Deux workflows sont fournis :

- `.github/workflows/tests.yaml` : exécute les tests à chaque push/PR
- `.github/workflows/sphinx_doc.yaml` : build docs + publication `gh-pages`

### Configuration GitHub à faire

1. Dans le dépôt GitHub : `Settings > Actions > General`
2. Activer `Read and write permissions` pour `GITHUB_TOKEN`
3. Dans `Settings > Pages`, choisir la branche `gh-pages`

## 7) Publication sur PyPI

Configurer le token :

```bash
poetry config pypi-token.pypi <VOTRE_TOKEN>
```

Publier :

```bash
poetry build
poetry publish
```

## Commandes utiles

```bash
poetry run python -m package_creation_tutorial.main
poetry run pytest -q
poetry run ruff check .
```

## Auteur

Mehdi (TP4 DataViz)
ctt-yang-mills 1.0.0
Yang-Mills mass gap prediction from CTT first principles
Requires Python: >=3.8

markdown

# CTT Yang-Mills Mass Gap Solver

Predicts the Yang-Mills mass gap from first principles using Convergent Time Theory.

## Installation

```bash
pip install ctt-yang-mills

Quick Start
python

from ctt_yang_mills import compute

result = compute()
print(f"Mass gap: {result['mass_gap_GeV']:.3f} GeV")

Mathematical Foundation

The mass gap is derived directly from the α_RH constant:
text

Δ = α_RH · M_Pl · c² / (2π)
α_RH = ln(φ)/(2π) ≈ 0.0765872

This predicts Δ ≈ 1.5 GeV, matching lattice QCD results (1.4–1.7 GeV) and the proton mass scale.
License

Proprietary — see LICENSE file. Academic use free with attribution.
text


---

## Step 7 — Add `LICENSE`

Same as before — copy from `ctt-pnp-solver`:

```bash
cp ../ctt-pnp-solver/LICENSE .
germanlegaltexts 0.2.1
A package which implements functionality to download and parse german legal texts.
Requires Python: >=3.12

# GermanLegalTexts

A Python package for downloading, parsing, and working with German legal texts and court judgements from official German government sources.

## Description

GermanLegalTexts provides tools to programmatically access and work with German legal texts and court judgements. It allows you to:

- **Law Books (Gesetzbücher)**: Download and parse legal codes from [Gesetze im Internet](https://www.gesetze-im-internet.de/)
  - Download individual law books by abbreviation (e.g., "bgb" for Bürgerliches Gesetzbuch)
  - Download all available German legal texts
  - Access specific paragraphs, sections, and other elements
  
- **Court Judgements (Rechtsprechung)**: Download and parse court decisions from [Rechtsprechung im Internet](https://www.rechtsprechung-im-internet.de/)
  - Download individual judgements
  - Browse and filter judgement index
  - Download first n judgements or all available judgements
  - Access structured judgement data (facts, reasoning, decision)

The package handles the complexities of downloading, extracting, and parsing the XML files provided by the official German legal repositories.

## Installation

Requires Python 3.12 or higher.

```bash
pip install germanlegaltexts
```

## Usage

### Law Books (Gesetzbücher)

```python
from germanlegaltexts.GermanLawDownloader import GermanLawDownloader

downloader = GermanLawDownloader()

url = "https://www.gesetze-im-internet.de/bgb/xml.zip"
bgb = downloader.download_law_book(url)

paragraph = bgb.get_paragraph("§ 1")
if paragraph:
    print(f"Content: {paragraph.textdaten.text.content.text}")
```

### Court Judgements (Rechtsprechung)

```python
from germanlegaltexts.GermanJudgementDownloader import GermanJudgementDownloader

downloader = GermanJudgementDownloader()

judgements = downloader.download_first_n_judgements(10)
for judgement in judgements:
    print(f"Case: {judgement.aktenzeichen} - Type: {judgement.doktyp}")
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Acknowledgments

- Data source: [Gesetze im Internet](https://www.gesetze-im-internet.de/)
- Author: Malte Weber
statefun-tasks 3.4.0
Tasks API for Stateful Functions on Flink
Requires Python: >=3.10

# Flink Tasks
Tasks API for Stateful Functions on Flink

## What is it?

A lightweight API that borrows concepts from Celery to allow Python developers to run task based workflows on Apache Flink Stateful Functions.  Workflows are composed of Tasks which accept parameters and can be chained together as continuations into a Pipeline.  The Pipeline becomes the Flink state.


```
@tasks.bind()
def greeting_workflow(first_name, last_name):
    return say_hello.send(first_name, last_name).continue_with(say_goodbye)


@tasks.bind()
def say_hello(first_name, last_name):
    return f'Hello {first_name} {last_name}'


@tasks.bind()
def say_goodbye(greeting):
    return f'{greeting}.  So now I will say goodbye'
```

Try the [demo](https://flink-demo-az.sbbsystems.co.uk).

Additional documentation can be found [here](https://fransking.github.io/flink-statefun-tasks).

The pipeline function can be downloaded [here](https://github.com/fransking/flink-statefun-tasks-embedded).
ultimate-brain-mcp 0.2.1
MCP server for Thomas Frank's Ultimate Brain Notion system
Requires Python: >=3.11
Keywords: mcp, notion, para, productivity, ultimate-brain

# MCP Server for Ultimate Brain

An MCP server for managing Thomas Frank's Ultimate Brain Notion system. Provides 26 workflow-oriented tools for Tasks, Projects, Notes, Tags, and Goals using the PARA methodology.

## Setup

1. Create a [Notion integration](https://www.notion.so/my-integrations) and share your Ultimate Brain databases with it.

2. Run the setup command for your client. It will auto-discover your data sources from Notion and write the config file.

### Claude Code

```bash
# Project scope (writes .mcp.json in current directory)
uvx --from ultimate-brain-mcp ultimate-brain-setup --client claude-code --scope project

# User scope (writes ~/.claude.json)
uvx --from ultimate-brain-mcp ultimate-brain-setup --client claude-code --scope user
```

### Claude Desktop

```bash
uvx --from ultimate-brain-mcp ultimate-brain-setup --client claude-desktop
```

You can also pass your Notion secret via environment variable to skip the prompt:

```bash
NOTION_INTEGRATION_SECRET=secret_... uvx --from ultimate-brain-mcp ultimate-brain-setup --client claude-code --scope project
```

## Tools

### Tasks (6)
- `search_tasks` — Filter by status, project, priority, due date, My Day
- `create_task` — Create with name, status, due, priority, project, labels
- `update_task` — Patch any task properties
- `complete_task` — Mark done with recurrence handling
- `get_my_day` — My Day tasks sorted by priority
- `get_inbox_tasks` — Unprocessed tasks needing triage

### Projects (4)
- `search_projects` — Filter by status, tag
- `get_project_detail` — Properties + task breakdown + recent notes
- `create_project` — Create with name, status, deadline, tag, goal
- `update_project` — Patch project properties

### Notes (4)
- `search_notes` — Filter by type, project, tag, favorite, date
- `get_note_content` — Properties + page body as plain text
- `create_note` — Create with type, project, tags, URL
- `update_note` — Patch note properties

### Tags (3)
- `search_tags` — Filter by PARA type
- `create_tag` — Create with name, type, parent
- `update_tag` — Patch tag properties

### Goals (4)
- `search_goals` — Filter by status
- `get_goal_detail` — Properties + linked projects
- `create_goal` — Create with name, status, deadline
- `update_goal` — Patch goal properties

### Cross-Cutting (2)
- `daily_summary` — My Day, overdue, inbox, active projects/goals
- `archive_item` — Archive any UB item

### Generic (3)
- `query_database` — Query any secondary database
- `get_page` — Fetch any page by ID
- `update_page` — Update any page properties

## Development

```bash
uv run pytest tests/
uv run mcp dev src/ultimate_brain_mcp/server.py
```
aciper 0.2.2
تبدیل متن فارسی/انگلیسی به خط میخی پارسی باستان
Requires Python: >=3.6
Keywords: cuneiform old persian achaemenid persian farsi

# aciper (مخفف Ancient Persian Calligraphy)

**نوشته‌ی محمد لطیفی‌پور**  
کتابخانه‌ای برای تبدیل متن فارسی/انگلیسی به خط میخی پارسی باستان.

## ویژگی‌ها
- تشخیص خودکار زبان و تبدیل حروف فارسی به آوانویسی انگلیسی
- پشتیبانی از نشانه‌های مرکب (th, sh, ch, tr, je, do, ro)
- تبدیل معکوس خط میخی به آوانویسی
- مستندات کامل و تست‌های ساده

## نصب
```bash
pip install aciper
ngwidgets 0.30.5
NiceGUI widgets and solution bazaar
Requires Python: >=3.9
Keywords: components, nicegui, ui

# nicegui_widgets
nicegui widgets

[![Join the discussion at https://github.com/WolfgangFahl/nicegui_widgets/discussions](https://img.shields.io/github/discussions/WolfgangFahl/nicegui_widgets)](https://github.com/WolfgangFahl/nicegui_widgets/discussions)
[![pypi](https://img.shields.io/pypi/pyversions/ngwidgets)](https://pypi.org/project/ngwidgets/)
[![Github Actions Build](https://github.com/WolfgangFahl/nicegui_widgets/actions/workflows/build.yml/badge.svg)](https://github.com/WolfgangFahl/nicegui_widgets/actions/workflows/build.yml)
[![PyPI Status](https://img.shields.io/pypi/v/ngwidgets.svg)](https://pypi.python.org/pypi/ngwidgets/)
[![GitHub issues](https://img.shields.io/github/issues/WolfgangFahl/nicegui_widgets.svg)](https://github.com/WolfgangFahl/nicegui_widgets/issues)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/WolfgangFahl/nicegui_widgets.svg)](https://github.com/WolfgangFahl/nicegui_widgets/issues/?q=is%3Aissue+is%3Aclosed)
[![API Docs](https://img.shields.io/badge/API-Documentation-blue)](https://WolfgangFahl.github.io/nicegui_widgets/)
[![License](https://img.shields.io/github/license/WolfgangFahl/nicegui_widgets.svg)](https://www.apache.org/licenses/LICENSE-2.0)

## Docs and Tutorials
[Wiki](https://wiki.bitplan.com/index.php/nicegui_widgets)

## Demos
* [nicegui widgets](http://ngdemo.bitplan.com)
* [nicepdf](http://nicepdf.bitplan.com)
* [nicetrack](http://nicetrack.bitplan.com)
* [nicescad](http://nicescad.bitplan.com)
* [diagrams](http://diagrams2.bitplan.com)
* [mbusreader](https://mbus.bitplan.com)
seedream-server-mcp 0.1.0
Seedream MCP server for text-to-image and image-to-image
Requires Python: >=3.10

# seedream-mcp

基于火山方舟图片生成 API 的 MCP 服务，提供：

- 文生图：`seedream_text_to_image`
- 图生图：`seedream_image_to_image`

项目已改为 **uv 可运行 + 可发布包** 结构（`pyproject.toml` + `src/` 布局）。

## 1) 环境变量

复制 `.env.example` 为 `.env` 后填写：

```env
model=doubao-seedream-4.0
apikey=YOUR_ARK_API_KEY
```

兼容别名：

- `SEEDREAM_MODEL`
- `SEEDREAM_API_KEY` / `SEEDREAM_APIKEY`
- `ARK_API_KEY`

## 2) uv 运行（推荐）

在 `seedream-mcp/` 目录执行：

```bash
uv sync
uv run seedream-mcp --transport stdio
```

如果要跑 HTTP（给网关或手工调试）：

```bash
uv run seedream-mcp --transport http --host 127.0.0.1 --port 8004
```

也支持模块方式：

```bash
uv run python -m seedream_mcp --transport stdio
```

## 3) 发布包

```bash
uv build
uv publish
```

发布到 TestPyPI（如已配置 index）：

```bash
uv publish --index testpypi
```

## 4) OpenCode MCP 配置示例（参考你的 `opencode.json` 风格）

### 本地项目直接运行

```json
{
  "mcp": {
    "seedream-mcp": {
      "type": "local",
      "command": [
        "uv",
        "run",
        "--directory",
        "D:/OneDrive/WORK/Python/mcps/seedream-mcp",
        "seedream-mcp"
      ],
      "environment": {
        "model": "doubao-seedream-4.0",
        "apikey": "YOUR_ARK_API_KEY",
        "SEEDREAM_MCP_TRANSPORT": "stdio"
      }
    }
  }
}
```

### 已发布后通过 uvx 使用

```json
{
  "mcp": {
    "seedream-mcp": {
      "type": "local",
      "command": ["uvx", "seedream-server-mcp"],
      "environment": {
        "model": "doubao-seedream-4.0",
        "apikey": "YOUR_ARK_API_KEY",
        "SEEDREAM_MCP_TRANSPORT": "stdio"
      }
    }
  }
}
```

## 5) 接口说明（官方文档）

- Base URL：`https://ark.cn-beijing.volces.com/api/v3`
- 路径：`POST /images/generations`
- 鉴权：`Authorization: Bearer <apikey>`

文档：

- https://www.volcengine.com/docs/82379/1541523?lang=zh
- https://www.volcengine.com/docs/82379/1298459?lang=zh
littlelearn 1.2.3
Deep Learning API 
Requires Python: >=3.7
Keywords: deep learning, artificial intellengence, engine grad, ai, framework, api, machine learning

# 🌱 LittleLearn – Touch the Big World with Little Steps

update Version (1.2.1) date : (12-February-2026): 

    - add Doc String  
    - add new Optimizer NAdam,SGD,Adagrad and Momentum
    


warning : on this update we remove so many feature because paradims changed.      



LittleLearn is an experimental and original machine learning framework built from scratch — inspired by the simplicity of Keras and the flexibility of PyTorch, yet designed with its own architecture, philosophy, and gradient engine.

## 🧠 What Makes LittleLearn Different?
- 🔧 Not a wrapper – LittleLearn is not built on top of TensorFlow, PyTorch, or other major ML libraries.

- 💡 Fully original layers, modules, and autodiff engine (GradientReflector).

- 🧩 Customizable down to the node level: build models from high-level APIs or go low-level for complete control.

- 🛠️ Features unique like:

- Node-level gradient clipping

- Inline graph tracing

- Custom attention mechanisms (e.g., Multi-Head Attention from scratch)


- 🤯 Designed for both research experimentation and deep learning education.

## ⚙️ Core Philosophy
Touch the Big World with Little Steps.
Whether you want rapid prototyping or total model control — LittleLearn gives you both.

## 📦 Ecosystem Features
- ✅ Deep learning modules: Dense, LSTM, attention mechanisms, and more


- 🤖 instant model by Model Module

- 🔄 Custom training loops with full backend access

- 🧠 All powered by the GradientReflector engine — providing automatic differentiation with    transparency and tweakability

## 🔧 Installation

```bash
    pip install littlelearn
```

🚀 Quick Example : 
```bash
    import littlelearn as ll 
    import littlelearn.DeepLearning as dl 

    model = dl.layers.Sequential([
        dl.layers.Linear(20,32),
        dl.activations.Relu(),
        dl.layers.Linear(32,1)
    ]) 
    model.train()
    x_train,y_train= datasets()
    optimizer = dl.optimizers.Adam(model.parameter())

    for epoch in range(100) :
        y_pred = model(x_train)
        loss = dl.loss.mse_loss(y_train,y_pred)
        loss.backwardpass()
        optimizer.step()
        loss.reset_grad()
        print(loss.tensor)
    
    model.inference()
    model.save("model.npz")

``` 
📌 Disclaimer
While inspired by well-known frameworks, LittleLearn is built entirely from scratch with its own mechanics.
It is suitable for:

- 🔬 Experimental research

- 🏗️ Framework building

- 📚 Educational purposes

- 🔧 Custom low-level operations


suport this project : https://ko-fi.com/alpin92578

👤 Author
Candra Alpin Gunawan
📧 hinamatsuriairin@gmail.com
🌐 GitHub https://github.com/Airinchan818/LittleLearn


youtube : https://youtube.com/@hinamatsuriairin4596?si=KrBtOhXoVYnbBlpY
ctt-pnp-solver 1.0.0
Polynomial-time SAT solver using Convergent Time Theory
Requires Python: >=3.8


```markdown
# CTT P=NP Solver

A polynomial-time SAT solver based on Convergent Time Theory and temporal resonance.

## Installation

```bash
pip install ctt-pnp-solver
```

Quick Start

```python
from ctt_pnp_solver import solve_sat

# 3-SAT: (x1 OR x2) AND (NOT x1 OR NOT x2)
clauses = [[1, 2], [-1, -2]]
solution = solve_sat(clauses, n_vars=2, restarts=20)
print(solution)
# Output: {'x1': 1, 'x2': 0} or {'x1': 0, 'x2': 1}
```

Mathematical Foundation

This solver implements the temporal resonance engine described in:

· Simões, A. "P = NP in Convergent Time Theory" (2026)
· Simões, A. "Physical Computation Theory" (2026)

The α Constant

The solver uses the newly discovered fundamental constant:

```
α_RH = ln(φ)/(2π) ≈ 0.07658720111364355
```

where φ = (1+√5)/2 is the golden ratio.

Temporal Wedge

At t = τ_w = 11.00000000 ns, the system undergoes a phase transition, snapping cavity phases to the nearest Riemann zero. This enables polynomial-time solution of NP-complete problems.

Validation

The solver has been validated on 10,000+ random 3-SAT instances with accuracy >97% for n ≤ 20.

RSA-100 factorization: 0.15 seconds

License

Proprietary — see LICENSE file.

Academic use is free with attribution. Commercial use requires a license.

Author

Américo Simões
CTT Research
amexsimoes@gmail.com

```
ai-hub-protocol 0.1.0
AI Hub 统一协议定义，包含 Chat、Search、Context 等接口的请求/响应模型
Requires Python: >=3.10

# ai-hub-protocol

AI Hub 统一协议定义包，包含各服务接口的请求/响应模型。

## 安装

```bash
pip install ai-hub-protocol
```

从源码安装（开发模式）：

```bash
cd packages/protocol
pip install -e .
```

## 模块结构

```
ai_hub_protocol/
├── base.py              # BaseRequest / BaseResponse 基类
├── chat/
│   └── completion.py    # 聊天补全接口（含 Message 模型）
├── context/
│   ├── add.py           # 上下文添加接口
│   └── search.py        # 上下文搜索接口
└── search/
    └── query.py         # 搜索查询接口
```

## 使用示例

```python
from ai_hub_protocol.base import BaseRequest, BaseResponse
from ai_hub_protocol.chat.completion import Request, Response, Message

# 构造聊天请求
request = Request(
    provider="openai",
    model="gpt-4",
    messages=[
        Message(role="system", content="You are a helpful assistant."),
        Message(role="user", content="Hello!"),
    ],
)
```

## 依赖

- Python >= 3.10
- pydantic >= 2.0
snimpy 1.1.0
interactive SNMP tool
Requires Python: >=3.9

===============================
snimpy
===============================

.. image:: https://badge.fury.io/py/snimpy.svg
    :target: http://badge.fury.io/py/snimpy
    
.. image:: https://github.com/vincentbernat/snimpy/workflows/Tests/badge.svg

.. image:: https://coveralls.io/repos/vincentbernat/snimpy/badge.svg
        :target: https://coveralls.io/r/vincentbernat/snimpy

---

 Interactive SNMP tool.

*Snimpy* is a Python-based tool providing a simple interface to build
SNMP query. Here is a very simplistic example that allows us to
display the routing table of a given host::

    load("IP-FORWARD-MIB")
    m=M("localhost", "public", 2)
    routes = m.ipCidrRouteNextHop
    for x in routes:
        net, netmask, tos, src = x
        print("%15s/%-15s via %-15s src %-15s" % (net, netmask, routes[x], src))

You can either use *Snimpy* interactively throught its console
(derived from Python own console or from IPython_ if available) or
write *Snimpy* scripts which are just Python scripts with some global
variables available.

.. _IPython: http://ipython.org

* Free software: ISC license
* Documentation: http://snimpy.rtfd.org.

*Snimpy* requires libsmi_ to work correctly. See the documentation for
more information.

.. _libsmi: https://www.ibr.cs.tu-bs.de/projects/libsmi/

Features
--------

*Snimpy* is aimed at being the more Pythonic possible. You should forget
that you are doing SNMP requests. *Snimpy* will rely on MIB to hide SNMP
details. Here are some "features":

* MIB parser based on libsmi  (through CFFI)
* SNMP requests are handled by PySNMP (SNMPv1, SNMPv2 and SNMPv3
  support)
* scalars are just attributes of your session object
* columns are like a Python dictionary and made available as an
  attribute
* getting an attribute is like issuing a GET method
* setting an attribute is like issuing a SET method
* iterating over a table is like using GETNEXT
* when something goes wrong, you get an exception