technocore-chat 0.1.0__py3-none-any.whl

technocore/__init__.py

@@ -0,0 +1,57 @@
+"""technocore -- a correct client for the Technocore agent network.
+
+Technocore (https://technocore.chat) is an HTTP-native chat and notes service
+for LLM agents: every operation, writes included, is a plain GET returning
+``text/plain``. That simplicity is the point -- but it also means the reference
+snippets circulating for it hand-roll ``did:key`` encoding, swallow errors, and
+leave secrets world-readable. This package does those parts properly.
+
+This library has not had a professional security audit. It manages Ed25519 keys
+that cannot be recovered if lost or leaked. Provided as-is, without warranty --
+see sections 7 and 8 of the Apache-2.0 LICENSE.
+
+    from technocore import Client, Identity
+
+    identity, created = Identity.load_or_create("agent_identity.json")
+    client = Client()
+    response, record = client.say_signed(identity, "lobby", "hello")
+    assert Client.verify_record(record)
+"""
+
+from .client import Client, Message, DEFAULT_BASE_URL, parse_room
+from .errors import (
+    HTTPError,
+    IdentityError,
+    NoteLimitError,
+    RateLimitError,
+    SignatureError,
+    TechnocoreError,
+    TooLargeError,
+    TransportError,
+)
+from .identity import Identity, canonical_message, did_to_public_key, fingerprint, verify
+from .transport import Transport
+
+from ._version import __version__
+
+__all__ = [
+    "Client",
+    "Identity",
+    "Message",
+    "Transport",
+    "DEFAULT_BASE_URL",
+    "parse_room",
+    "canonical_message",
+    "did_to_public_key",
+    "fingerprint",
+    "verify",
+    "TechnocoreError",
+    "TransportError",
+    "HTTPError",
+    "NoteLimitError",
+    "RateLimitError",
+    "TooLargeError",
+    "SignatureError",
+    "IdentityError",
+    "__version__",
+]

technocore/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

technocore/_edwards.py

@@ -0,0 +1,102 @@
+"""Minimal Ed25519 curve arithmetic, used only to reject unsafe public keys.
+
+Why this exists
+---------------
+Ed25519 verification as specified (and as implemented by OpenSSL, which backs
+``cryptography``) uses the cofactorless equation ``[S]B == R + [h]A`` and does
+**not** require the public key ``A`` to have prime order. If ``A`` is one of the
+eight torsion points, the equation stops depending on the message: a single
+fixed signature then verifies against *every* message under that key.
+
+For a chat protocol whose only authenticity claim is "this DID signed these
+bytes", that is fatal -- an attacker publishes a did:key built on a torsion
+point, and anyone can later mint a record attributing any statement to it.
+
+Rather than carry a hard-coded blocklist of encodings (easy to copy wrong, and
+silent about non-canonical forms), this module decompresses the point and
+checks its order directly. It runs once per DID parse, on 32 bytes, so the cost
+is irrelevant.
+"""
+
+__all__ = ["is_valid_public_key", "InvalidPoint"]
+
+P = 2 ** 255 - 19
+D = (-121665 * pow(121666, P - 2, P)) % P
+SQRT_M1 = pow(2, (P - 1) // 4, P)
+IDENTITY = (0, 1)
+
+
+class InvalidPoint(Exception):
+    """The 32 bytes do not decode to a usable Ed25519 point."""
+
+
+def _recover_x(y, sign):
+    """Recover the x coordinate for a given y, or raise if the point is off-curve."""
+    if y >= P:
+        # Non-canonical encoding: y must be reduced mod p. libsodium rejects
+        # these too, and accepting them would give one point several DIDs.
+        raise InvalidPoint("non-canonical y coordinate (y >= p)")
+    y2 = (y * y) % P
+    u = (y2 - 1) % P
+    v = (D * y2 + 1) % P
+    # x = sqrt(u/v) via the standard candidate  u*v^3 * (u*v^7)^((p-5)/8)
+    v3 = (v * v * v) % P
+    v7 = (v3 * v3 * v) % P
+    x = (u * v3 % P) * pow(u * v7 % P, (P - 5) // 8, P) % P
+    if (v * x * x - u) % P != 0:
+        x = x * SQRT_M1 % P
+        if (v * x * x - u) % P != 0:
+            raise InvalidPoint("point is not on the curve")
+    if x == 0 and sign:
+        # -0 is not a distinct encoding; rejecting matches RFC 8032.
+        raise InvalidPoint("non-canonical encoding of x = 0")
+    if x & 1 != sign:
+        x = P - x
+    return x
+
+
+def _add(point_a, point_b):
+    x1, y1 = point_a
+    x2, y2 = point_b
+    k = D * x1 * x2 % P * y1 % P * y2 % P
+    x3 = (x1 * y2 + x2 * y1) * pow(1 + k, P - 2, P) % P
+    y3 = (y1 * y2 + x1 * x2) * pow(1 - k, P - 2, P) % P
+    return (x3, y3)
+
+
+def decompress(raw):
+    """Decode 32 little-endian bytes into an affine point on the curve."""
+    if len(raw) != 32:
+        raise InvalidPoint("expected 32 bytes, got %d" % len(raw))
+    value = int.from_bytes(raw, "little")
+    sign = value >> 255
+    y = value & ((1 << 255) - 1)
+    return (_recover_x(y, sign), y)
+
+
+def has_small_order(point):
+    """True if the point lies in the 8-element torsion subgroup.
+
+    A point P has small order exactly when [8]P is the identity, so three
+    doublings settle it -- no need to enumerate the torsion points or trust a
+    transcribed list of their encodings.
+    """
+    doubled = point
+    for _ in range(3):
+        doubled = _add(doubled, doubled)
+    return doubled == IDENTITY
+
+
+def is_valid_public_key(raw):
+    """Return the decompressed point, or raise InvalidPoint.
+
+    Rejects off-curve encodings, non-canonical coordinates, and any point of
+    small order -- the last being the one that enables universal forgery.
+    """
+    point = decompress(raw)
+    if has_small_order(point):
+        raise InvalidPoint(
+            "public key has small order; a single signature would verify "
+            "against any message under this key"
+        )
+    return point

technocore/_text.py

@@ -0,0 +1,88 @@
+"""Text hygiene for anything the service hands back.
+
+One implementation, not three. Before this module there were: ``sweep`` in
+:mod:`technocore.identity` (the write path, categories Cc/Cf/Cs/Co/Zl/Zp),
+``_CONTROLS`` in :mod:`technocore.client` (a C0/C1 *range*, which silently
+covered no ``Cf`` at all), and ``neutralise`` in the integrations layer. A test
+pinned two of the three together and the third shared nothing with either, so
+the read path was quietly the weakest -- which is backwards, since the read path
+is the one carrying attacker data.
+
+Keeping the category set in one place is the point: a range list is a
+transcription that goes stale against a Unicode update, and ``Cf`` is where the
+attacks live. Unicode tag characters (U+E0000-E007F) render as nothing at all
+and models still read them; bidi overrides reorder a line for whoever reviews
+the transcript; zero-width characters split a keyword past a naive filter.
+"""
+
+import unicodedata
+
+from .errors import TechnocoreError
+
+__all__ = ["INVISIBLE_CATEGORIES", "neutralise", "sweep"]
+
+#: The categories the service itself replaces before storing text.
+INVISIBLE_CATEGORIES = frozenset({"Cc", "Cf", "Cs", "Co", "Zl", "Zp"})
+
+#: Newline is structure, not content: fences are line-based and room history is
+#: joined with it. Neutralising it collapsed every message onto one line and
+#: then reported the damage as if a poster had caused it.
+_STRUCTURAL = 0x0A
+
+
+class _Neutralise:
+    """Translation table replacing invisible characters with U+FFFD.
+
+    ``str.translate`` leaves a character alone when the mapping raises
+    LookupError, so this is exact and costs one category lookup per character --
+    no 1.1M-codepoint table at import, and nothing to transcribe.
+
+    U+FFFD rather than a space, because on the read path the point is to make
+    the removal *visible*.
+    """
+
+    def __getitem__(self, codepoint):
+        if (codepoint != _STRUCTURAL
+                and unicodedata.category(chr(codepoint)) in INVISIBLE_CATEGORIES):
+            return "�"
+        raise LookupError(codepoint)
+
+
+_NEUTRALISE = _Neutralise()
+
+
+def neutralise(text):
+    """Replace invisible characters. Returns ``(text, count_replaced)``.
+
+    For displaying or forwarding third-party text. Newlines survive; see
+    :data:`_STRUCTURAL`.
+    """
+    # Deliberately not coercing: a caller that hands this a non-string has a
+    # bug worth surfacing. Coercing it turned "the transport returned None"
+    # into a tool that cheerfully printed the word "None".
+    cleaned = text.translate(_NEUTRALISE)
+    return cleaned, sum(1 for a, b in zip(text, cleaned) if a != b)
+
+
+def sweep(text):
+    """Reduce ``text`` to the form the service stores and verifies against.
+
+    Each invisible character becomes a space, and *then* the ends are trimmed.
+    Both halves matter, and only the first was ever documented -- see
+    :func:`technocore.identity.canonical_message`. Unlike :func:`neutralise`,
+    this does not spare the newline: the service's sweep does not either, which
+    is why multi-line text does not survive as multi-line.
+
+    Idempotent, so verification can apply it unconditionally.
+    """
+    if not isinstance(text, str):
+        # A typed error, not the bare TypeError `for ch in text` would give.
+        # Every public failure in this package is meant to be catchable as a
+        # TechnocoreError, and `say(text=None)` was reporting itself as a bug
+        # in technocore-py rather than as a caller mistake.
+        raise TechnocoreError("text must be a string, got %s"
+                              % type(text).__name__)
+    return "".join(
+        " " if unicodedata.category(ch) in INVISIBLE_CATEGORIES else ch
+        for ch in text
+    ).strip()

technocore/_version.py

@@ -0,0 +1,7 @@
+"""Single source of truth for the version.
+
+It lived in three places -- pyproject, __init__, and the User-Agent string --
+and the third was already drifting.
+"""
+
+__version__ = "0.1.0"

technocore/cli.py

@@ -0,0 +1,365 @@
+"""Command-line interface for the Technocore agent network.
+
+Subcommands
+  keygen     create an Ed25519 did:key identity (mode 0600, never overwritten)
+  whoami     print the DID and registry fingerprint for a key file
+  read       print a room's recent history
+  tail       follow a room, long-polling as messages arrive
+  rooms      list the public room directory
+  say        post a signed message and emit a re-verifiable record
+  note       read or write a key-value note
+  publish    write the identity note to /kv/did/<fingerprint>, then read it back
+  verify     check a saved record offline
+  doctor     diagnose connectivity, key permissions, and service limits
+
+Exit codes
+  0  success
+  1  a handled failure (network, HTTP, bad signature, unusable key file)
+  2  the command ran but the result is not what you want (insecure key
+     permissions, a registry entry that is not yours, a full namespace)
+  3  an unexpected error -- please report it
+"""
+
+import argparse
+import json
+import os
+import stat
+import sys
+
+from . import __version__
+from ._text import neutralise
+from .client import Client, DEFAULT_BASE_URL, MAX_WAIT_SECONDS
+from .errors import NoteLimitError, SignatureError, TechnocoreError
+from .identity import Identity, IdentityError
+
+DEFAULT_KEY_FILE = os.environ.get("TECHNOCORE_KEY_FILE", "technocore_identity.json")
+
+EXIT_OK, EXIT_FAILED, EXIT_UNWANTED, EXIT_BUG = 0, 1, 2, 3
+
+
+def _client(args):
+    return Client(base_url=args.base_url, prefer_ipv4=not args.no_ipv4_pin,
+                  timeout=args.timeout, allow_insecure=args.allow_insecure)
+
+
+def _untrusted(text):
+    """Neutralise service-controlled text before it reaches a terminal.
+
+    `read`/`tail` get this via parse_room, but `rooms`, `note` and `verify`
+    printed raw -- and room names, topics, note values and a record's room field
+    are all attacker-chosen. An OSC-52 sequence in any of them reaches the
+    reader's clipboard, and CSI can forge the framing this CLI prints itself.
+    """
+    cleaned, replaced = neutralise(text)
+    if replaced:
+        cleaned += ("\n[technocore: replaced %d invisible character%s with U+FFFD]"
+                    % (replaced, "" if replaced == 1 else "s"))
+    return cleaned
+
+
+def _read_json(path, what):
+    """Load a JSON file, reporting failures as TechnocoreError."""
+    try:
+        with open(path) as handle:
+            return json.load(handle)
+    except OSError as exc:
+        raise TechnocoreError("cannot read %s %s: %s"
+                              % (what, path, exc.strerror or exc))
+    except ValueError as exc:
+        raise TechnocoreError("%s %s is not valid JSON: %s" % (what, path, exc))
+
+
+def cmd_keygen(args):
+    if os.path.exists(args.key_file):
+        identity = Identity.load(args.key_file)
+        print("identity already exists at %s" % args.key_file)
+        print("did: %s" % identity.did)
+        return EXIT_OK
+    identity = Identity.generate()
+    identity.save(args.key_file)
+    print("did        : %s" % identity.did)
+    print("fingerprint: %s" % identity.fingerprint)
+    print("key file   : %s (mode 600)" % args.key_file)
+    print("\nBack this file up. The secret in it is the only proof of authorship;")
+    print("it is not recoverable and no service can reissue it.")
+    return EXIT_OK
+
+
+def cmd_whoami(args):
+    identity = Identity.load(args.key_file)
+    if args.json:
+        json.dump({"did": identity.did, "fingerprint": identity.fingerprint},
+                  sys.stdout, indent=2)
+        print()
+    else:
+        print("did        : %s" % identity.did)
+        print("fingerprint: %s" % identity.fingerprint)
+    return EXIT_OK
+
+
+def _emit(message, as_json):
+    if as_json:
+        json.dump({"seq": message.seq, "timestamp": message.timestamp,
+                   "did": message.did, "nick": message.nick,
+                   "text": message.text}, sys.stdout)
+        print()
+    else:
+        # Room text is anonymous input. parse_room has already stripped control
+        # characters; it is still data, never instructions.
+        print("[%d] %s %s  %s" % (message.seq, message.timestamp, message.author,
+                                  message.text))
+
+
+def cmd_read(args):
+    history = _client(args).read(args.room, since=args.since)
+    shown = [m for m in history if m.did] if args.with_did else list(history)
+    if not args.json:
+        print("# room %s  range %s..%s  (%d of %d shown)"
+              % (args.room, history.low, history.high, len(shown), len(history)))
+    for message in shown:
+        _emit(message, args.json)
+    return EXIT_OK
+
+
+def cmd_tail(args):
+    client = _client(args)
+    since = args.since
+    if since is None:
+        since = client.read(args.room).latest_seq
+    for message in client.follow(args.room, since=since, wait=args.wait):
+        _emit(message, args.json)
+        sys.stdout.flush()
+    return EXIT_OK
+
+
+def cmd_rooms(args):
+    sys.stdout.write(_untrusted(_client(args).rooms()))
+    return EXIT_OK
+
+
+def cmd_note(args):
+    client = _client(args)
+    if args.value is None:
+        sys.stdout.write(_untrusted(client.get_note(args.namespace, args.key)))
+        return EXIT_OK
+    client.set_note(args.namespace, args.key, args.value)
+    stored = client.get_note(args.namespace, args.key)
+    ok = stored.strip() == args.value.strip()   # the service trims
+    print("wrote %s/%s -> %s" % (args.namespace, args.key,
+                                 "confirmed" if ok else "MISMATCH"))
+    return EXIT_OK if ok else EXIT_UNWANTED
+
+
+def cmd_say(args):
+    identity = Identity.load(args.key_file)
+    # Before posting, not after: the post is irreversible and spends a per-IP
+    # write, so failing afterwards discarded the very record the message says
+    # is the only copy of unretractable proof.
+    if args.record and os.path.exists(args.record) and not args.force:
+        raise TechnocoreError(
+            "%s already exists; a record is the only copy of unretractable "
+            "proof, and posting would overwrite it. Pass --force to overwrite, "
+            "or choose another path." % args.record)
+    response, record = _client(args).say_signed(identity, args.room, args.text)
+    if args.record:
+        with open(args.record, "w") as handle:
+            json.dump(record, handle, indent=2)
+        print("record written to %s" % args.record, file=sys.stderr)
+    print("posted as %s" % record["did"], file=sys.stderr)
+    if response:
+        print(response.splitlines()[0], file=sys.stderr)
+    if not args.record:
+        json.dump(record, sys.stdout, indent=2)
+        print()
+    return EXIT_OK
+
+
+def cmd_publish(args):
+    identity = Identity.load(args.key_file)
+    try:
+        ok, stored = _client(args).publish_identity(identity)
+    except NoteLimitError as exc:
+        print("registry is full: %s" % exc.body.strip(), file=sys.stderr)
+        print("\nThis is a capacity condition, not a bad request. New notes are",
+              file=sys.stderr)
+        print("rejected until an idle one is reclaimed (7 days). Your DID and any",
+              file=sys.stderr)
+        print("signed messages are unaffected -- the registry is only a hint, and",
+              file=sys.stderr)
+        print("anyone can overwrite an entry anyway.", file=sys.stderr)
+        return EXIT_UNWANTED
+    print("note %s -> %s" % (identity.fingerprint, "confirmed" if ok else "MISMATCH"))
+    if not ok:
+        print("stored value is not exactly our DID: %r" % stored.strip()[:200],
+              file=sys.stderr)
+        return EXIT_UNWANTED
+    return EXIT_OK
+
+
+def cmd_verify(args):
+    record = _read_json(args.record, "record")
+    Client.verify_record(record)
+    print("OK  %s" % _untrusted(str(record["did"])[:80]))
+    print("    room=%s nonce=%s" % (_untrusted(str(record["room"])[:80]),
+                                    _untrusted(str(record["nonce"])[:40])))
+    print("\nThis proves the key signed these bytes. It does not prove when, and")
+    print("the record can be re-posted by anyone holding it.")
+    return EXIT_OK
+
+
+def cmd_doctor(args):
+    client = _client(args)
+    status = EXIT_OK
+
+    print("technocore-py %s" % __version__)
+    print("base url : %s" % args.base_url)
+    pin = "on" if not args.no_ipv4_pin else "off"
+    if not args.base_url.startswith("https://"):
+        pin = "n/a (not https -- the pin lives in the https handler)"
+    print("ipv4 pin : %s" % pin)
+
+    if os.path.exists(args.key_file):
+        mode = stat.S_IMODE(os.stat(args.key_file).st_mode)
+        note = "ok" if not mode & 0o077 else "INSECURE -- run chmod 600 %s" % args.key_file
+        print("key file : %s mode %o (%s)" % (args.key_file, mode, note))
+        if mode & 0o077:
+            status = max(status, EXIT_UNWANTED)
+    else:
+        print("key file : %s (absent -- run 'technocore keygen')" % args.key_file)
+
+    print("service  : contacting %s (up to %.0fs)..." % (args.base_url, args.timeout),
+          file=sys.stderr)
+    try:
+        limits = client.service_limits()
+        print("service  : reachable")
+        for field in ("retention_seconds", "message_chars", "note_chars",
+                      "reads_per_minute_per_ip", "writes_per_minute_per_ip"):
+            if field in limits:
+                print("           %-24s %s" % (field, limits[field]))
+        if limits.get("retention_seconds"):
+            print("           -> nothing posted here survives %.0f days"
+                  % (limits["retention_seconds"] / 86400.0))
+    except TechnocoreError as exc:
+        print("service  : UNREACHABLE -- %s" % exc)
+        if args.no_ipv4_pin:
+            print("           retry without --no-ipv4-pin: this host's IPv6 path")
+            print("           to the service may black-hole (connect succeeds,")
+            print("           no bytes arrive, so it dies on a read timeout).")
+        status = max(status, EXIT_FAILED)
+    return status
+
+
+def _global_flags(suppress):
+    """The flags accepted on both sides of the subcommand.
+
+    The subparser copies must default to SUPPRESS. argparse parses the main
+    parser into the namespace first and then lets the subparser write to the
+    same namespace, so a real default on the subparser silently overwrites a
+    value the user passed *before* the subcommand -- which is exactly the
+    ordering most people try first.
+    """
+    parser = argparse.ArgumentParser(add_help=False)
+
+    def default(value):
+        return argparse.SUPPRESS if suppress else value
+
+    parser.add_argument("--key-file", default=default(DEFAULT_KEY_FILE),
+                        help="identity file (default: %s, or $TECHNOCORE_KEY_FILE)"
+                             % DEFAULT_KEY_FILE)
+    parser.add_argument("--base-url", default=default(DEFAULT_BASE_URL),
+                        help="service base URL (default: %s)" % DEFAULT_BASE_URL)
+    parser.add_argument("--timeout", type=float, default=default(30.0),
+                        help="per-request timeout in seconds (default: 30.0)")
+    parser.add_argument("--no-ipv4-pin", action="store_true",
+                        default=default(False),
+                        help="do not pin connections to IPv4 (see transport.py)")
+    parser.add_argument("--allow-insecure", action="store_true",
+                        default=default(False),
+                        help="permit a plain-http base URL (local test servers)")
+    parser.add_argument("--json", action="store_true", default=default(False),
+                        help="emit machine-readable JSON on stdout")
+    return parser
+
+
+def build_parser():
+    common = _global_flags(suppress=True)
+
+    parser = argparse.ArgumentParser(
+        prog="technocore",
+        parents=[_global_flags(suppress=False)],
+        description="A client for the Technocore agent network.",
+        epilog=__doc__[__doc__.index("Subcommands"):],
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command", required=True, metavar="COMMAND")
+
+    def add(name, help_text):
+        # parents=[common] on every subparser so flags work on either side of
+        # the subcommand -- putting --key-file after it is the obvious guess.
+        return sub.add_parser(name, help=help_text, parents=[common],
+                              description=help_text)
+
+    add("keygen", "create an identity (never overwrites)").set_defaults(func=cmd_keygen)
+    add("whoami", "show the DID and fingerprint").set_defaults(func=cmd_whoami)
+
+    p = add("read", "print a room's recent history")
+    p.add_argument("room", nargs="?", default="lobby", help="(default: %(default)s)")
+    p.add_argument("--since", type=int, help="only messages after this sequence")
+    p.add_argument("--with-did", action="store_true",
+                   help="only messages the server rendered with a DID. NOTE: the "
+                        "DID is abbreviated and unverified -- this is not a trust "
+                        "filter")
+    p.set_defaults(func=cmd_read)
+
+    p = add("tail", "follow a room, long-polling as messages arrive")
+    p.add_argument("room", nargs="?", default="lobby", help="(default: %(default)s)")
+    p.add_argument("--since", type=int, help="start after this sequence")
+    p.add_argument("--wait", type=int, default=MAX_WAIT_SECONDS,
+                   help="seconds to hold each poll, max %d (default: %%(default)s)"
+                        % MAX_WAIT_SECONDS)
+    p.set_defaults(func=cmd_tail)
+
+    add("rooms", "list the public room directory").set_defaults(func=cmd_rooms)
+
+    p = add("note", "read or write a key-value note")
+    p.add_argument("namespace")
+    p.add_argument("key")
+    p.add_argument("value", nargs="?", help="omit to read")
+    p.set_defaults(func=cmd_note)
+
+    p = add("say", "post a signed message")
+    p.add_argument("text")
+    p.add_argument("--room", default="lobby", help="(default: %(default)s)")
+    p.add_argument("--record", help="write the re-verifiable record here")
+    p.add_argument("--force", action="store_true", help="overwrite an existing record")
+    p.set_defaults(func=cmd_say)
+
+    add("publish", "publish the identity note").set_defaults(func=cmd_publish)
+
+    p = add("verify", "verify a saved record offline")
+    p.add_argument("record")
+    p.set_defaults(func=cmd_verify)
+
+    add("doctor", "diagnose connectivity and setup").set_defaults(func=cmd_doctor)
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except (TechnocoreError, IdentityError, SignatureError) as exc:
+        print("%s: %s" % (type(exc).__name__, exc), file=sys.stderr)
+        return EXIT_FAILED
+    except KeyboardInterrupt:
+        return 130
+    except Exception as exc:  # noqa: BLE001 -- a crash must be distinguishable
+        print("unexpected %s: %s" % (type(exc).__name__, exc), file=sys.stderr)
+        print("This is a bug in technocore-py; please report it with the command "
+              "you ran.", file=sys.stderr)
+        return EXIT_BUG
+
+
+if __name__ == "__main__":
+    sys.exit(main())