envread 0.2.0__py3-none-any.whl

envread/_specfile.py

@@ -0,0 +1,78 @@
+"""Read the plain-text spec format used by the ``envread check`` command.
+
+One variable per line: ``NAME TYPE [optional] [secret]``. Blank lines and lines
+starting with ``#`` are ignored. TYPE is one of ``str int float bool decimal path
+duration json secret``, ``list`` or ``list:SEP`` (items split on SEP, comma by
+default), or ``choice:A,B,C`` (exactly one of the listed words).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ._check import VarSpec
+from ._parsers import parse_list
+from ._types import NAMED, Parser, choice_parser, parse_secret
+
+TYPE_HELP = "str, int, float, bool, decimal, path, duration, json, list[:SEP], choice:A,B"
+_FLAGS = frozenset({"optional", "secret"})
+
+
+class SpecError(ValueError):
+    """A spec line or a ``--type`` value is malformed."""
+
+
+def parse_type(token: str) -> tuple[Parser, str]:
+    """Return the parser and display name for a type token such as ``list:;``."""
+    kind, _, argument = token.partition(":")
+    if kind == "list":
+        separator = argument or ","
+        return (lambda name, raw: parse_list(name, raw, separator)), "list"
+    if kind == "choice":
+        choices = tuple(word for word in argument.split(",") if word)
+        if not choices:
+            raise SpecError("choice needs at least one word, for example choice:dev,prod")
+        return choice_parser(choices), "choice"
+    if not argument and kind in NAMED:
+        return NAMED[kind], kind
+    raise SpecError(f"unknown type {token!r}; expected one of {TYPE_HELP}")
+
+
+def parse_spec(text: str, source: str = "spec") -> list[VarSpec]:
+    """Turn spec text into variable specs, raising SpecError naming the bad line."""
+    specs: list[VarSpec] = []
+    for number, line in enumerate(text.splitlines(), start=1):
+        words = line.split()
+        if not words or words[0].startswith("#"):
+            continue
+        try:
+            specs.append(_line(words))
+        except SpecError as exc:
+            raise SpecError(f"{source}:{number}: {exc}") from None
+    return specs
+
+
+def _line(words: list[str]) -> VarSpec:
+    if len(words) < 2:
+        raise SpecError("expected NAME TYPE [optional] [secret]")
+    name, token, *flags = words
+    unknown = [flag for flag in flags if flag not in _FLAGS]
+    if unknown:
+        raise SpecError(f"unknown flag {unknown[0]!r}; expected optional or secret")
+    parser: Parser
+    if token == "secret":
+        parser, type_name = parse_secret, "secret"
+    else:
+        parser, type_name = parse_type(token)
+    return VarSpec(
+        name=name,
+        type_name=type_name,
+        parser=parser,
+        required="optional" not in flags,
+        secret="secret" in flags or token == "secret",
+        attr=name,
+    )
+
+
+def read_spec(path: str) -> list[VarSpec]:
+    return parse_spec(Path(path).read_text(encoding="utf-8-sig"), path)

envread/_types.py

@@ -0,0 +1,110 @@
+"""Map a type annotation, or a type name from a spec file, to a parser."""
+
+from __future__ import annotations
+
+import types
+from collections.abc import Callable
+from datetime import timedelta
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from typing import Any, Literal, Union, get_args, get_origin
+
+from ._duration import parse_duration
+from ._errors import InvalidEnvError
+from ._parsers import (
+    parse_bool,
+    parse_choice,
+    parse_decimal,
+    parse_enum,
+    parse_float,
+    parse_int,
+    parse_json,
+    parse_path,
+    parse_str,
+    split_list,
+)
+from ._secret import Secret
+
+Parser = Callable[[str, str], Any]
+
+SCALARS: dict[Any, tuple[Parser, str]] = {
+    str: (parse_str, "str"),
+    int: (parse_int, "int"),
+    float: (parse_float, "float"),
+    bool: (parse_bool, "bool"),
+    Decimal: (parse_decimal, "decimal"),
+    Path: (parse_path, "path"),
+    timedelta: (parse_duration, "duration"),
+}
+
+NAMED: dict[str, Parser] = {name: parser for parser, name in SCALARS.values()}
+NAMED["json"] = parse_json
+
+
+def parse_secret(name: str, raw: str) -> Secret:
+    return Secret(raw)
+
+
+def split_parser(item: Parser, separator: str, kind: Callable[[list[Any]], Any]) -> Parser:
+    """Build a parser that splits on ``separator`` and parses every item."""
+
+    def parse(name: str, raw: str) -> Any:
+        values = []
+        for index, part in enumerate(split_list(raw, separator), start=1):
+            try:
+                values.append(item(name, part))
+            except InvalidEnvError as exc:
+                # The reason must never quote the item: masking keeps the reason.
+                why = f"item {index} is not a valid {exc.type_name}"
+                why += f" ({exc.reason})" if exc.reason else ""
+                raise InvalidEnvError(name, raw, "list", why) from None
+        return kind(values)
+
+    return parse
+
+
+def choice_parser(choices: tuple[str, ...]) -> Parser:
+    return lambda name, raw: parse_choice(name, raw, choices)
+
+
+def _json_object(name: str, raw: str) -> dict[str, Any]:
+    value = parse_json(name, raw)
+    if not isinstance(value, dict):
+        raise InvalidEnvError(name, raw, "JSON object", "expected a JSON object")
+    return value
+
+
+def unwrap_optional(annotation: Any) -> tuple[Any, bool]:
+    """Return ``(inner, True)`` for ``X | None`` / ``Optional[X]``, else ``(annotation, False)``."""
+    if get_origin(annotation) in (Union, types.UnionType):
+        args = [arg for arg in get_args(annotation) if arg is not type(None)]
+        if len(args) == 1 and len(args) < len(get_args(annotation)):
+            return args[0], True
+    return annotation, False
+
+
+def resolve(annotation: Any, separator: str) -> tuple[Parser, str]:
+    """Return the parser and a readable type name for a field annotation.
+
+    Raises TypeError for an annotation this package cannot read from a string.
+    """
+    if annotation in SCALARS:
+        return SCALARS[annotation]
+    if annotation is Secret:
+        return parse_secret, "secret"
+    if isinstance(annotation, type) and issubclass(annotation, Enum):
+        enum_type = annotation
+        return (lambda name, raw: parse_enum(name, raw, enum_type)), enum_type.__name__
+    origin, args = get_origin(annotation), get_args(annotation)
+    if origin is Literal and args and all(isinstance(arg, str) for arg in args):
+        return choice_parser(tuple(args)), "choice"
+    if origin is dict or annotation is dict:
+        return _json_object, "JSON object"
+    if origin in (list, tuple) and args:
+        homogeneous = origin is list or (len(args) == 2 and args[1] is Ellipsis)
+        if homogeneous and args[0] in SCALARS:
+            item, item_name = SCALARS[args[0]]
+            kind: Callable[[list[Any]], Any] = list if origin is list else tuple
+            return split_parser(item, separator, kind), f"{origin.__name__}[{item_name}]"
+    raise TypeError(f"envread cannot read a field annotated {annotation!r} from a string")

envread/_version.py

@@ -0,0 +1,3 @@
+"""Single source of truth for the package version."""
+
+__version__ = "0.2.0"

envread-0.2.0.dist-info/METADATA

@@ -0,0 +1,269 @@
+Metadata-Version: 2.5
+Name: envread
+Version: 0.2.0
+Summary: Typed reader for environment variables: inferred return types, settings dataclasses, .env files and a checker CLI, zero dependencies
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/typedenv
+Project-URL: Issues, https://github.com/JaviLianes8/typedenv/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/typedenv/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: 12factor,config,dotenv,env,environment,environment-variables,settings,typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: python-dotenv; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Requires-Dist: typing-extensions; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# envread
+
+Typed reader for environment variables with mypy-inferred return types, settings
+dataclasses, `.env` files and a checker CLI. Zero dependencies.
+
+## Install
+
+```
+pip install envread
+```
+
+## Read one variable
+
+```python
+from envread import env
+
+database_url = env.str("DATABASE_URL")  # str, raises MissingEnvError if unset
+port = env.int("PORT", 8080)  # int, the default when unset
+workers = env.int("WORKERS", None)  # int | None
+debug = env.bool("DEBUG", False)  # true/false, yes/no, on/off, 1/0, ...
+hosts = env.list("ALLOWED_HOSTS")  # split on "," and trimmed
+timeout = env.duration("TIMEOUT", None)  # "90", "250ms", "1h30m" -> timedelta
+api_key = env.secret("API_KEY")  # Secret: prints as ***
+```
+
+Every getter takes the same arguments and the static type follows the call:
+
+| call | type | when unset |
+| --- | --- | --- |
+| `env.int("X")` | `int` | raises `MissingEnvError` |
+| `env.int("X", required=True)` | `int` | raises `MissingEnvError` |
+| `env.int("X", 8080)` | `int` | `8080` |
+| `env.int("X", None)` | `int \| None` | `None` |
+| `env.int("X", required=False)` | `int \| None` | `None` |
+
+| getter | returns | accepts |
+| --- | --- | --- |
+| `str` | `str` | anything, returned as is (`""` stays `""`) |
+| `int` | `int` | base-10 integer, surrounding whitespace ignored |
+| `float` | `float` | anything `float()` accepts |
+| `bool` | `bool` | `true/false`, `yes/no`, `on/off`, `1/0`, `y/n`, `t/f`, `enable(d)/disable(d)`, any case |
+| `decimal` | `Decimal` | exact decimal; `NaN` and infinities are rejected |
+| `path` | `Path` | non-empty path, taken literally (no `~` expansion) |
+| `duration` | `timedelta` | seconds (`90`, `1.5`) or units `w d h m s ms` from largest to smallest (`1h30m`) |
+| `enum` | your `Enum` | member name in any case, or the member value as text |
+| `list` | `list[str]` | split on `separator=` (default `,`), items trimmed, `""` is `[]` |
+| `json` | `Any` | JSON, parsed by the standard library |
+| `secret` | `Secret` | anything, wrapped so it never prints |
+
+The boolean words match the default vocabulary of
+[boolish](https://pypi.org/project/boolish/), without depending on it.
+
+## Load a settings dataclass
+
+```python
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Literal
+
+from envread import Env, Secret, load, var
+
+
+@dataclass(frozen=True)
+class Settings:
+    database_url: Secret  # DATABASE_URL, required
+    port: int = 8080  # PORT
+    workers: int | None = None  # WORKERS, optional
+    hosts: list[str] = field(default_factory=list)
+    timeout: timedelta = timedelta(seconds=5)
+    mode: Literal["dev", "prod"] = "dev"
+    token: str = var("SERVICE_TOKEN", default="", secret=True)
+    ports: tuple[int, ...] = var(default=(), separator=";")
+
+
+settings = load(Settings)  # from os.environ
+settings = load(Settings, Env(prefix="APP_"))  # APP_DATABASE_URL, APP_PORT, ...
+```
+
+There is no base class and no metaclass: `load` reads `dataclasses.fields()` and the
+annotations. The variable name is the field name upper-cased, or `var(name=...)`. A
+field with a default, a `default_factory` or an `X | None` annotation is optional.
+Supported annotations: `str`, `int`, `float`, `bool`, `Decimal`, `Path`, `timedelta`,
+`Secret`, any `Enum`, `Literal["a", "b"]`, `dict[...]` (a JSON object), and `list[X]` or
+`tuple[X, ...]` of a scalar type. Anything else raises `TypeError` when `load` runs.
+
+`load` reads every field before raising, so one run reports every problem:
+
+```
+EnvValidationError: 3 environment variables failed validation:
+  - required environment variable 'DATABASE_URL' is not set
+  - environment variable 'PORT' is not a valid integer: 'eighty'
+  - environment variable 'MODE' is not a valid choice: 'staging': expected one of dev, prod
+```
+
+The individual errors are in `error.errors`. If you lint with ruff, add
+`extend-immutable-calls = ["envread.var"]` under `[tool.ruff.lint.flake8-bugbear]`
+so `var()` is treated like `field()`.
+
+## Secrets
+
+`secret=True` on any getter, `var(secret=True)`, or a `Secret` annotation keeps the
+value out of error messages, the error's `value` attribute (`"***"`) and the exception
+chain, so even an uncaught traceback does not show it. A `Secret` prints as `***` in
+`str`, `repr`, f-strings and dataclass reprs; call `.reveal()` where the real value is
+needed. It compares in constant time and refuses to be pickled. `secret=True` alone only
+protects errors; annotate the field as `Secret` to keep it out of the dataclass repr too.
+
+## Prefixes, empty values and presence
+
+```python
+app = Env(prefix="APP_")  # app.int("PORT") reads APP_PORT
+db = app.prefixed("DB_")  # db.str("HOST") reads APP_DB_HOST
+strict = Env(empty_is_unset=True)  # KEY= counts as unset
+env.raw("PORT")  # the unparsed string, or None
+env.is_set("PORT"), "PORT" in env  # presence
+cfg = Env({"PORT": "9090"})  # any mapping instead of os.environ
+```
+
+## Platform facts
+
+- **Names**: `os.environ` is case-insensitive on Windows (keys are stored upper-case)
+  and case-sensitive on POSIX, so `env.str("path")` finds `PATH` on Windows only. A
+  plain `dict` source is always exact.
+- **Values** are always strings; there is no `None` in the environment. A variable can
+  be set to `""`, which is different from unset unless you pass `empty_is_unset=True`.
+- **Length**: on Windows `os.environ` refuses an entry whose `NAME=value` is longer
+  than 32,767 characters, although a child process can receive longer values through
+  `subprocess` `env=`. `load_dotenv` checks this up front and raises `DotenvError`.
+
+## `.env` files
+
+```python
+from envread import load_dotenv, parse_dotenv, read_dotenv
+
+load_dotenv(".env")  # set what is not already set; returns what it set
+load_dotenv(".env", override=True)  # the file wins
+values = read_dotenv(".env")  # dict, environment untouched
+```
+
+The supported syntax is a subset of python-dotenv 1.x, tested line by line against
+python-dotenv itself:
+
+| syntax | result |
+| --- | --- |
+| blank lines, `# comment` lines | ignored |
+| `export KEY=value`, `KEY = value` | `export` and spaces around `=` are allowed |
+| `KEY=plain value  # note` | `plain value` (an inline `#` needs a space before it) |
+| `KEY='literal \n $X'` | taken literally; only `\'` and `\\` are escapes |
+| `KEY="a\tb ${X}"` | escapes `\\ \' \" \a \b \f \n \r \t \v`, then expansion |
+| `${NAME}`, `${NAME:-default}` | earlier keys, then the environment; unknown is `""` |
+| `KEY` (no `=`) | skipped |
+| `KEY=` | `""` |
+
+Expansion order follows python-dotenv: `read_dotenv` and `parse_dotenv` prefer earlier
+keys in the file, `load_dotenv` prefers the existing environment unless `override=True`.
+The default in `${NAME:-default}` applies only when `NAME` is unset. Unquoted `$NAME`
+without braces is literal.
+
+Anything else raises `DotenvError` with the file and line, never the value:
+multi-line quoted values, other `${...}` forms (`${X-d}`, `${X:?err}`, nesting), text
+after a closing quote, and `${` inside single quotes (python-dotenv expands it, docker
+compose keeps it literal). Docker compose `env_file` also expands unbraced `$NAME`
+and treats `${NAME:-default}` as "unset or empty", so files that rely on those
+compose-only behaviours read differently there.
+
+## Command line
+
+```
+envread check env.spec                     validate every variable in a spec file
+envread check myapp.settings:Settings      validate the fields of a dataclass
+envread check env.spec --env-file .env     layer a .env file under the environment
+envread check env.spec --format json       machine-readable report
+envread get PORT --type int --default 8080 print one parsed value
+envread get DEBUG --type bool              prints true or false
+```
+
+A spec file lists one variable per line as `NAME TYPE [optional] [secret]`, with types
+`str int float bool decimal path duration json secret`, `list[:SEP]` and
+`choice:A,B,C`:
+
+```
+# deployment contract
+DATABASE_URL  secret
+PORT          int       optional
+LOG_LEVEL     choice:debug,info,warning
+HOSTS         list:;
+```
+
+```
+$ envread check env.spec
+ok       DATABASE_URL  secret
+invalid  PORT          int, optional: not a valid integer: 'eighty'
+missing  LOG_LEVEL     choice: not set
+ok       HOSTS         list
+envread: 2 of 4 variables failed
+```
+
+`check` exits 0 when every variable is valid and 1 otherwise, so it gates a deploy
+script directly. Values are printed only with `--show-values`, and secrets never are.
+`--prefix`, `--env-file` and `--empty-is-unset` work on both commands; `--quiet` gives
+an exit code only. Errors go to stderr with exit code 1. `python -m envread` works the same
+as the `envread` script.
+
+## Errors
+
+`MissingEnvError` is also a `KeyError`; `InvalidEnvError`, `EnvValidationError` and
+`DotenvError` are also `ValueError`s; all of them derive from `EnvError`.
+
+## Why
+
+Reading config from the environment is a one-liner until you want the value typed, a
+missing variable to fail loudly, every failure reported in one go, secrets kept out of
+logs, and your type checker to agree with all of it. The existing options each give up
+one of those or pull in dependencies: `environs` needs `marshmallow` and
+`python-dotenv`, `environ-config` is built on `attrs`, `pydantic-settings` pulls in
+`pydantic-core`, and `typenv` depends on `python-dotenv` and has not shipped since 2021.
+
+`envread` has no runtime dependencies, ships `py.typed`, and uses `@overload` so
+`env.int("X")` is `int` and `env.int("X", None)` is `int | None` with no casts. Reach
+for it when you want typed environment access and a deploy-time check without adding a
+settings framework to the project.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

envread-0.2.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+envread/__init__.py,sha256=d3_0iA2PakvMLNMgP9dHTaAbYGdrpX0S7TiYtCPHfKk,683
+envread/__main__.py,sha256=pnI90LA6TY7WQCY_EKn_kWt1tAbMSmCN253VTkiqT0A,129
+envread/_check.py,sha256=Bd5gjZF4OZkrg3W5tvqtZVwC6Z7v5u8C3PpfNXRjviI,2129
+envread/_cli.py,sha256=5pnqJ-0s7a_29earM3Lfk-LBG_d6CS3XMtKnWTHmloA,6036
+envread/_dotenv.py,sha256=aU8K5lbaXrW-fNVj7JIewKPZElc04k7qSxvC7vKnBKc,4534
+envread/_dotenv_value.py,sha256=emPcCBbDbt_uNPLcujFk7hTFbj9yjsJFuYayPMDJo8Q,3158
+envread/_duration.py,sha256=l33Dxkf8vxLabzY8zW-HpWhCr8XR0JAoF6-feWXPlLE,1750
+envread/_env.py,sha256=0RReXtrg4nUgW8tF6fWBPoP3ZGg88iIpK0vv8m-wyvY,5740
+envread/_errors.py,sha256=224yi3Jd6bKsnuAWLlACNenBMqp8zioTwMN8Xn5ocq8,3431
+envread/_parsers.py,sha256=6pWdk1ogPRGLkidtCsnJ3aL9d5e6Y4R_FdUaO7IOZ9E,3633
+envread/_reader.py,sha256=WJptZApgKTDVmZV6rvMHE3gdvPqBTW6K7vkoCVr_NQI,3800
+envread/_report.py,sha256=zgXQPRKRIBFQHEoCRLayjWhCATjwNPDn7REpTuEShxs,3090
+envread/_rich.py,sha256=cma2krJ7XIEgl_qpZnuZIkIZg9TFLbdL4UPRK8caDrA,4886
+envread/_secret.py,sha256=TU6DoAxmQHC6adAj_WRwzjvBJtQzfDEa58X5cBc6yoI,1849
+envread/_settings.py,sha256=Y8QHXRzkJT5UMaS_IlxLGixWNaUlWp9gnfF216tNeXM,3818
+envread/_specfile.py,sha256=UFeXC45A64GjKcEW7aABLVtqjEO9NmTlElGVvdAN_8w,2838
+envread/_types.py,sha256=9hWs44aK1bTE06wocc2C3Y6-HiJFOgg9mcvsfqEP5OE,3972
+envread/_version.py,sha256=qma9hy2PH3uT1-7KbTvB6thSsXLqsU_hMKESUJVJ_H0,77
+envread/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+envread-0.2.0.dist-info/METADATA,sha256=0u93WcxEAPONL7ka48bdtCh-thJX-zzbRwxtKsoHgkA,11513
+envread-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+envread-0.2.0.dist-info/entry_points.txt,sha256=sPiHHk_I5nSu7WCjzVHD5COWk22LUYHeuvHZ2p2q21E,46
+envread-0.2.0.dist-info/licenses/LICENSE,sha256=wirD5nCA2aQa5UusK_1YHLBogI3CGcw23xAnulp3L_U,1091
+envread-0.2.0.dist-info/RECORD,,

envread-0.2.0.dist-info/WHEEL

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

envread-0.2.0.dist-info/entry_points.txt

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

envread-0.2.0.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.