lvxml 0.2.1__py3-none-any.whl

lvxml/_treejson.py

@@ -0,0 +1,162 @@
+"""Check a tree's shape against the schema and convert it to and from JSON-ready dicts."""
+
+from __future__ import annotations
+
+from ._errors import LVXMLError
+from ._node import LVDATA_NAMESPACE, Document, Node
+from ._parse import MAX_DEPTH
+from ._schema import ARRAY_ITEM_TAGS, CLUSTERED_TAGS, ENUM_RANGES, SIMPLE_TAGS, VALUE_TAGS
+
+_EXTRA_ORDER = ("RefKind", "RefType", "ActiveXType.GUID", "ActiveXType.Name", "DotNetType.Name")
+_NEEDS = {"RefType": "RefKind", "ActiveXType.Name": "ActiveXType.GUID"}
+_FIELDS = ("name", "val", "choices", "dims", "num_elts", "items", "extra")
+
+
+def check_shape(node: Node, path: str, depth: int = 1) -> None:
+    """Raise unless `node` only uses the parts LVXMLSchema.xsd gives its tag."""
+    tag = node.tag
+    here = f"{path}/{tag}" if path else tag
+    if depth > MAX_DEPTH:
+        raise LVXMLError(f"nesting deeper than {MAX_DEPTH} levels is not supported", path)
+    if tag not in VALUE_TAGS:
+        raise LVXMLError(f"unknown LabVIEW type tag {tag!r}", here)
+    used = {f for f in _FIELDS[1:] if getattr(node, f) not in (None, ())}
+    allowed = _allowed(tag)
+    if used - allowed or (allowed & {"val", "num_elts", "dims", "choices"}) - used:
+        raise LVXMLError(f"<{tag}> takes {sorted(allowed)}, got {sorted(used)}", here)
+    if (node.num_elts or 0) < 0 or any(dim < 0 for dim in node.dims):
+        raise LVXMLError("NumElts and Dimsize cannot be negative", here)
+    keys = [key for key, _ in node.extra]
+    order = [_EXTRA_ORDER.index(k) if k in _EXTRA_ORDER else -1 for k in keys]
+    if -1 in order or order != sorted(set(order)):
+        raise LVXMLError(f"Refnum fields must be a subset of {list(_EXTRA_ORDER)} in order", here)
+    for key, needed in _NEEDS.items():
+        if key in keys and needed not in keys:
+            raise LVXMLError(f"Refnum field {key} needs {needed}", here)
+    members = frozenset({"Cluster"}) if tag in CLUSTERED_TAGS else _members(tag)
+    for item in node.items:
+        if item.tag not in members:
+            raise LVXMLError(f"<{item.tag}> is not allowed inside <{tag}>", here)
+        check_shape(item, here, depth + 1)
+
+
+def _allowed(tag: str) -> set[str]:
+    if tag in SIMPLE_TAGS:
+        return {"val"}
+    if tag in ENUM_RANGES:
+        return {"val", "choices"}
+    if tag == "Refnum":
+        return {"val", "extra"}
+    if tag == "Array":
+        return {"dims", "items"}
+    if tag == "Cluster":
+        return {"num_elts", "items"}
+    return {"items"}
+
+
+def _members(tag: str) -> frozenset[str]:
+    return ARRAY_ITEM_TAGS if tag == "Array" else VALUE_TAGS
+
+
+def node_to_dict(node: Node) -> dict[str, object]:
+    data: dict[str, object] = {"tag": node.tag}
+    if node.tag != "Version":
+        data["name"] = node.name
+    if node.val is not None:
+        data["val"] = node.val
+    if node.choices:
+        data["choices"] = list(node.choices)
+    if node.dims:
+        data["dims"] = list(node.dims)
+    if node.num_elts is not None:
+        data["num_elts"] = node.num_elts
+    if node.extra:
+        data["extra"] = [list(pair) for pair in node.extra]
+    if node.items or node.tag in {"Array", "Cluster", "LvVariant"} | CLUSTERED_TAGS:
+        data["items"] = [node_to_dict(item) for item in node.items]
+    return data
+
+
+def document_to_dict(document: Document) -> dict[str, object]:
+    return {
+        "wrapped": document.wrapped,
+        "namespace": document.namespace,
+        "items": [node_to_dict(node) for node in document.items],
+    }
+
+
+def _get(data: dict[str, object], key: str, kind: type, path: str) -> object:
+    value = data.get(key)
+    if value is not None and (
+        not isinstance(value, kind) or isinstance(value, bool) != (kind is bool)
+    ):
+        raise LVXMLError(f"field {key!r} must be {kind.__name__}", path)
+    return value
+
+
+def _strings(value: object, key: str, path: str) -> tuple[str, ...]:
+    items = value if isinstance(value, list) else []
+    if not all(isinstance(item, str) for item in items):
+        raise LVXMLError(f"field {key!r} must be a list of strings", path)
+    return tuple(str(item) for item in items)
+
+
+def node_from_dict(data: object, path: str, depth: int = 1) -> Node:
+    if depth > MAX_DEPTH:
+        raise LVXMLError(f"nesting deeper than {MAX_DEPTH} levels is not supported", path)
+    if not isinstance(data, dict):
+        raise LVXMLError("a node must be an object", path)
+    unknown = set(data) - {"tag", *_FIELDS}
+    if unknown:
+        raise LVXMLError(f"unknown node fields {sorted(unknown)}", path)
+    tag = _get(data, "tag", str, path)
+    if not isinstance(tag, str):
+        raise LVXMLError("a node needs a string 'tag'", path)
+    here = f"{path}/{tag}" if path else tag
+    if tag != "Version" and "name" not in data:
+        raise LVXMLError("a node needs a 'name' (use \"\" for an unnamed one)", here)
+    dims = _get(data, "dims", list, here) or []
+    assert isinstance(dims, list)
+    if not all(isinstance(d, int) and not isinstance(d, bool) and d >= 0 for d in dims):
+        raise LVXMLError("field 'dims' must be a list of non-negative ints", here)
+    extra = _get(data, "extra", list, here) or []
+    assert isinstance(extra, list)
+    pairs = tuple(_strings(pair, "extra", here) for pair in extra)
+    if any(len(pair) != 2 for pair in pairs):
+        raise LVXMLError("field 'extra' must hold [key, text] pairs", here)
+    items = _get(data, "items", list, here) or []
+    assert isinstance(items, list)
+    num_elts = _get(data, "num_elts", int, here)
+    name, val = _get(data, "name", str, here), _get(data, "val", str, here)
+    return Node(
+        tag,
+        name=name if isinstance(name, str) else "",
+        val=val if isinstance(val, str) else None,
+        choices=_strings(_get(data, "choices", list, here), "choices", here),
+        dims=tuple(int(d) for d in dims),
+        num_elts=num_elts if isinstance(num_elts, int) else None,
+        items=tuple(node_from_dict(item, here, depth + 1) for item in items),
+        extra=tuple((pair[0], pair[1]) for pair in pairs),
+    )
+
+
+def document_from_dict(data: object) -> Document:
+    if not isinstance(data, dict) or not isinstance(data.get("items"), list):
+        raise LVXMLError("a document must be an object with an 'items' list")
+    unknown = set(data) - {"wrapped", "namespace", "items"}
+    if unknown:
+        raise LVXMLError(f"unknown document fields {sorted(unknown)}")
+    wrapped, namespace = data.get("wrapped", True), data.get("namespace", LVDATA_NAMESPACE)
+    if not isinstance(wrapped, bool) or not (namespace is None or isinstance(namespace, str)):
+        raise LVXMLError("'wrapped' must be a bool and 'namespace' a string or null")
+    root = "LVData" if wrapped else ""
+    nodes = tuple(node_from_dict(item, root) for item in data["items"])
+    for node in nodes:
+        if node.tag == "Version" and wrapped and node.name == "" and node.val is not None:
+            if node.items or node.choices or node.dims or node.extra or node.num_elts is not None:
+                raise LVXMLError("a Version entry only takes 'val'", root)
+            continue
+        check_shape(node, root)
+    if not wrapped and len(nodes) != 1:
+        raise LVXMLError("a bare document holds exactly one value")
+    return Document(nodes, wrapped=wrapped, namespace=namespace)

lvxml-0.2.1.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.5
+Name: lvxml
+Version: 0.2.1
+Summary: Codec for LabVIEW Flatten To XML / Unflatten From XML between its fixed schema and native Python values
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/lvxml
+Project-URL: Issues, https://github.com/JaviLianes8/lvxml/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/lvxml/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: codec,flatten,labview,ni,unflatten,xml
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: editables; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: lxml; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# lvxml
+
+Codec for LabVIEW Flatten To XML / Unflatten From XML between its fixed schema and native
+Python values. Typed, zero dependencies, Python 3.10+.
+
+## Install
+
+```
+pip install lvxml
+```
+
+## Read LabVIEW XML as Python values
+
+LabVIEW's Flatten To XML emits a fixed shape: each value is an element named after its
+datatype (`DBL`, `I32`, `Boolean`, `String`, `Array`, `Cluster`, ...), carrying a `<Name>`
+and either a `<Val>` or, for containers, `<Dimsize>` or `<NumElts>` and child elements.
+
+```python
+from lvxml import from_lv_xml, from_lv_xml_all
+
+from_lv_xml("<I32><Name>count</Name><Val>-7</Val></I32>")
+# -7
+
+from_lv_xml(
+    "<Cluster><Name>pt</Name><NumElts>2</NumElts>"
+    "<DBL><Name>x</Name><Val>1.0</Val></DBL>"
+    "<I32><Name>y</Name><Val>5</Val></I32></Cluster>"
+)
+# {'x': 1.0, 'y': 5}
+
+with open("Example Flattened XML File.xml", encoding="utf-8") as f:
+    from_lv_xml_all(f.read())  # every value in an <LVData> file, Version header skipped
+```
+
+| LabVIEW element | Python value |
+| --- | --- |
+| `I8` `I16` `I32` `I64` `U8` `U16` `U32` `U64` | `int`, range checked |
+| `SGL` `DBL` `EXT` | `float` (`NaN`, `Inf`, `-Inf` accepted) |
+| `CSG` `CDB` `CXT` | `complex`, from `re +im i` text |
+| `Boolean` | `bool` (`1`/`0`, also `true`/`false`) |
+| `String` `Path` `DAQChannel` | `str` |
+| `EB` `EW` `EL` enums | the selected `<Choice>` label |
+| `Refnum` | its `<Val>` text |
+| `Array` | `list`, nested once per `<Dimsize>`, row-major |
+| `Cluster` | `dict` keyed by field name, in order |
+| `LvVariant`, `Timestamp`, `WDT`, `DynamicData`, `DigitalData`, waveforms | `list` of their items' values |
+
+A cluster whose fields share a name (LabVIEW allows unnamed fields) cannot become a dict
+without losing data, so it raises; read it through the typed tree below instead.
+
+## Write Python values as LabVIEW XML
+
+A schema names the LabVIEW type of each value, since a Python `int` could be any width
+and a `list` any element type:
+
+```python
+from lvxml import Array, Cluster, LVEnum, to_lv_xml
+
+to_lv_xml([1.0, 2.5], Array("DBL"), name="xs")
+to_lv_xml([[1, 2], [3, 4]], Array("I32", ndim=2), name="grid")
+to_lv_xml(
+    {"x": 1.5, "flag": True, "mode": "Run", "z": 1 - 2j},
+    Cluster({"x": "DBL", "flag": "Boolean", "mode": LVEnum(("Idle", "Run")), "z": "CDB"}),
+    name="pt",
+)
+```
+
+A scalar schema is a tag string: any integer, float or complex tag above, `"Boolean"`,
+`"String"`, `"Path"` or `"DAQChannel"`. `Array(element, ndim=1)` is an array (LabVIEW has
+no array of arrays, so `element` cannot be an `Array`), `Cluster(fields)` an ordered
+mapping of field name to schema, and `LVEnum(choices, tag="EW")` an enum whose value may
+be given as a label or an index. An empty array is written with `Dimsize` 0 and one
+default element, so the element type stays visible. `to_node` builds the typed tree
+instead of text.
+
+## The typed tree: lossless read and write
+
+`parse` keeps everything: names, the raw `<Val>` text, enum choices, `Dimsize`,
+`NumElts`, refnum fields and the `<Version>` header. `dump` writes it back in the layout
+LabVIEW's file writer uses (one element per line, CRLF, no indentation), so a file
+LabVIEW wrote comes back byte for byte.
+
+```python
+from lvxml import dump, parse, to_value
+
+with open("Example Flattened XML File.xml", encoding="utf-8", newline="") as f:
+    text = f.read()  # newline="" keeps LabVIEW's CRLF line breaks
+
+document = parse(text)
+document.version  # '26.3.1f1'
+node = document.values[3]  # Node(tag='Cluster', name='Random Graph Data', num_elts=3, ...)
+to_value(node)  # the plain Python value
+assert dump(document) == text
+document.to_dict()  # JSON-ready; Document.from_dict() reverses it
+```
+
+`dump(tree, newline="\r\n", indent="", declaration=None)` also writes a single `Node`
+bare, the way Flatten To XML returns it, and refuses a node the schema cannot express.
+
+## Validate
+
+`validate(text)` returns a list of problems, empty when the document is good. It first
+checks the element structure `LVXMLSchema.xsd` defines, then every value: numbers that
+parse and fit their type, enum indexes inside their choices, and `NumElts` and `Dimsize`
+that match the elements present. Each problem names its location, such as
+`Cluster[pt]/I8[y]: 300 is out of range for I8 (-128..127)`. Problems in the data raise
+`LVXMLError` (a `ValueError`) with the same location in its `path` attribute. Building an
+impossible schema object, such as `LVEnum(())`, raises `ValueError` or `TypeError`.
+
+`parse`, `from_lv_xml`, `from_lv_xml_all` and `validate` take `str` or `bytes`; bytes are
+decoded by the encoding the XML declaration names, or as UTF-8.
+
+## Command line
+
+```
+lvxml to-json data.xml -o data.json      # lossless tree, every name and raw value kept
+lvxml to-json --values data.xml          # plain values: numbers, strings, lists, dicts
+lvxml to-xml data.json -o data.xml       # tree JSON back to LabVIEW XML
+lvxml validate data.xml other.xml        # check shape and values, exit 1 on any problem
+echo "<I32><Name>n</Name><Val>7</Val></I32>" | lvxml to-json --values -
+```
+
+`-` reads standard input. `--encoding` sets the file encoding (default `utf-8`); if a
+file is not UTF-8, name its encoding, for example `--encoding cp1252`.
+`to-xml --newline lf` switches from CRLF. `--values` writes strict JSON: complex numbers
+become `{"re": ..., "im": ...}` and non-finite floats the strings `"NaN"`, `"Inf"` and
+`"-Inf"`. Errors go to standard error with exit status 1. `lvxml --help` lists
+everything.
+
+## What each rule rests on
+
+Checked against the real LabVIEW file in the tests:
+
+- The layout `dump` writes by default: the `<?xml version='1.0' standalone='yes' ?>`
+  declaration, `<LVData xmlns="http://www.ni.com/LVData">`, a `<Version>` header, one
+  element per line, CRLF, no indentation and no final line break.
+- `DBL`, `Cluster` and one-dimensional `Array` values, and decimals written with a period.
+
+Checked against the shipped XSD: the element structure of every type, including
+multi-dimensional `Array` (repeated `<Dimsize>`), the enum `<Choice>` list and the
+optional `Refnum` fields. The XSD declares the target namespace
+`http://www.ni.com/labview` while the real file uses `http://www.ni.com/LVData`; the
+reader accepts either, or none, keeps whichever it found, and requires every element to
+share the root's namespace.
+
+Taken from the format strings in LabVIEW 2026's run-time library (`lvrt.dll`), with no
+real sample in the tests yet:
+
+- complex values as `re +im i` (the writer's `<Val>%s +%s i</Val>`);
+- only `&`, `<` and `>` escaped in text (the only entity strings beside the XML
+  writer's tags are `&lt;`, `&gt;` and `&amp;`), so quotes are written as they are;
+- integers and `Dimsize` as plain decimals (`%d`, `%lld`, `%llu`).
+
+Choices `lvxml` makes where neither source settles the question:
+
+- `Boolean` is written as `1` or `0`; the reader also accepts `true` and `false`.
+- Non-finite floats are written as `NaN`, `Inf` and `-Inf` (the spellings found in the
+  run-time library) and read case-insensitively.
+- Floats are written with the shortest text that reads back exactly. A comma decimal
+  separator raises.
+- A carriage return inside a value is written as is and survives a read with `lvxml`,
+  where a plain XML parser would turn it into a line feed.
+- A DOCTYPE or a CDATA section is refused, nesting deeper than 100 levels raises, and an
+  empty array whose shape would expand to more than 100000 nested lists raises.
+
+## Test fixtures
+
+The tests check the codec against ground truth from a LabVIEW 2026 installation:
+
+- `LVXMLSchema.xsd` is the schema LabVIEW ships in
+  `C:\Program Files\National Instruments\LabVIEW 2026\vi.lib\Utility\LVXMLSchema.xsd`.
+  It belongs to NI, so it is not in the repository or the sdist: run
+  `python scripts/capture_ni.py` on a machine with LabVIEW to copy it into
+  `tests/fixtures/ni` (size and sha256 are checked against `tests/fixtures/ni/MANIFEST.json`).
+  Without it, the tests that validate against the schema skip.
+- `tests/fixtures/real/example-flattened-xml-file.xml` is **real LabVIEW output**,
+  kept byte for byte: the file `Example Flattened XML File.xml` that LabVIEW 2026
+  (version header `26.3.1f1`) wrote to `Documents\LabVIEW Data` when running the shipped
+  example `examples\File IO\XML\Flatten and Unflatten XML\Flatten Data and Write to XML
+  File.vi`. It holds `DBL` values and a `Cluster` with a ten-element `Array`.
+- `tests/fixtures/schema/*.xml` are **schema-derived**: written by hand from the XSD to
+  cover every element it defines. They are valid against the XSD, but their payloads are
+  illustrative; in particular the cluster contents of the timestamp and waveform elements
+  are not LabVIEW's actual internal layout, which the schema does not specify.
+
+The real file and every schema-derived fixture are validated against the XSD with `lxml`
+(a test-only dependency) when the schema is present, parsed, decoded, and written back: the real file byte for byte,
+the others canonically equal. Samples that the XSD rejects are rejected by the reader as
+well. An end-to-end test installs the package and drives the installed `lvxml` command
+on the real file.
+
+## Not covered
+
+Fixed-point `FXP` numbers and the `<Default>` and `<Attributes>` children of a variant
+appear among the run-time library's writer strings but are absent from the shipped
+schema, so the reader raises a clear error for them. The
+timestamp and waveform elements are read as the schema describes them (a name and
+clusters), not interpreted further.
+
+## Why
+
+LabVIEW's Flatten To XML and Unflatten From XML use one fixed schema
+(`LVXMLSchema.xsd`): datatype-named elements, `Name`-ordered fields, a period decimal
+separator independent of locale. LabVIEW produces and reads this schema natively, and NI's
+community GXML library also converts data to and from XML, but both run inside LabVIEW and
+ship no Python reader. On the Python side, with no LabVIEW running, a generic XML library
+parses the tree but knows nothing of that convention, so turning it into usable Python, or
+producing XML LabVIEW will accept, is left to hand-written glue every time. Existing LabVIEW
+Python packages (pylabview, lvkit, autolv) parse VI source files, not this flattened data
+format, and no package on PyPI covers it. `lvxml` is a small, typed, zero-dependency codec
+for it.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

lvxml-0.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+lvxml/__init__.py,sha256=9kdAkJ6PDUtLxACYM6xvgNeEg7CsFU7wQ35rw2Kwtp8,711
+lvxml/__main__.py,sha256=NLpeMnqLH4XzLgQ3fPCHFeDMnSZeEZnsayREEBSUfqQ,166
+lvxml/_checks.py,sha256=cp3PhaqK9x_vOAKu7aWCUXyWPLgwkbkjiEczmnuOqkA,4014
+lvxml/_cli.py,sha256=VrEqbFSFPrRFSMyccdn9nq3-dTRj4xsgL57w4Mra-T0,6204
+lvxml/_decode.py,sha256=HQldZuAHgIVIT8tG4cnXdCEJbzGofOdl-gLwtw8eGHs,3898
+lvxml/_dump.py,sha256=dDcpXdFYqN9Z0fo34Ruw52Giq3Uti2e07kmohF9cVUk,4178
+lvxml/_encode.py,sha256=fN2QyGoTYZObabLQ8YNuDs7DYdgJduO2HEwbWzVpmhE,6358
+lvxml/_errors.py,sha256=FLku5mi8pmmQ4u705R5VbBYGEvrb6m-0Fz4jz-4NENI,565
+lvxml/_load.py,sha256=AxyAfEj_e1UKta1EIUhHqj8py-zr56LnYW2ESxi4sPo,2256
+lvxml/_node.py,sha256=9_lloysh7j3Vly_QT9ataUbblh8Zn_PXoO375kH2FIk,3037
+lvxml/_numbers.py,sha256=l2hfDFVh3lcO5IEPePst9azyN_OaVU52iRXvB3sLnQQ,3133
+lvxml/_parse.py,sha256=Xh7bkDRPx11DFPdQ6gK1vz9sm6g3z9jNgQYvDxiJ-9M,6310
+lvxml/_schema.py,sha256=GAHQwDeeE0Z82DhOF3a2aiRcquzfaR4HynViwp9D-L8,4129
+lvxml/_treejson.py,sha256=9QcFfoV8d8pyfvPHDT4qklOfo7BqTNp7m2Jsd_NCDEs,7263
+lvxml/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lvxml-0.2.1.dist-info/METADATA,sha256=RdYIFeAyuSpwVIEnR2bq6goaIVF7WExS0uVboaMpRl0,11860
+lvxml-0.2.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lvxml-0.2.1.dist-info/entry_points.txt,sha256=v-2V1KUgAKDBVy7sm8fVfO0wkujOfr1KbDcX72oJd4Q,42
+lvxml-0.2.1.dist-info/licenses/LICENSE,sha256=wirD5nCA2aQa5UusK_1YHLBogI3CGcw23xAnulp3L_U,1091
+lvxml-0.2.1.dist-info/RECORD,,

lvxml-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

lvxml-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lvxml = lvxml._cli:main

lvxml-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.