"""Original teaching protocol, not a provider SDK. Python 3.11+, stdlib only.
No network, keys, GPU, or randomness. Feed arbitrary byte fragments.
Supports LF, CRLF and CR lines, UTF-8 BOM, comments and multiline data.
Does not implement EventSource reconnect, retry or Last-Event-ID semantics.
"""
import codecs
import json
import math

class Stream:
    def __init__(self, max_event=65536):
        self.decoder = codecs.getincrementaldecoder('utf-8-sig')('strict')
        self.line = ''
        self.data = []
        self.event = ''
        self.cr = False
        self.size = 0
        self.max_event = max_event
        self.text = ''
        self.state = 'waiting'

    def feed(self, chunk):
        self.consume(self.decoder.decode(chunk))

    def consume(self, text):
        for c in text:
            if c == '\n' and self.cr:
                self.cr = False
                continue
            self.cr = False
            if c in '\r\n':
                self.on_line(self.line)
                self.line = ''
                self.cr = c == '\r'
            else:
                self.line += c
                if len(self.line.encode('utf-8')) > self.max_event:
                    raise ValueError('line too large')

    def on_line(self, line):
        if not line:
            self.dispatch()
            self.data, self.event, self.size = [], '', 0
            return
        if line.startswith(':'):
            return
        field, _, value = line.partition(':')
        if value.startswith(' '):
            value = value[1:]
        if field == 'event':
            self.event = value
        elif field == 'data':
            self.size += len(value.encode('utf-8')) + 1
            if self.size > self.max_event:
                raise ValueError('event too large')
            self.data.append(value)

    def dispatch(self):
        if not self.data:
            return
        if self.state in {'completed', 'failed'}:
            raise ValueError('data after terminal state')
        payload = json.loads('\n'.join(self.data))
        if not isinstance(payload, dict):
            raise ValueError('payload must be object')
        if self.event == 'delta':
            if not isinstance(payload.get('text'), str):
                raise ValueError('delta.text must be string')
            self.text += payload['text']
            self.state = 'streaming'
        elif self.event == 'done':
            if payload.get('reason') != 'stop':
                raise ValueError('not an accepted completion')
            self.state = 'completed'
        elif self.event == 'error':
            self.state = 'failed'
        else:
            raise ValueError('unknown teaching event')

    def finish(self):
        self.consume(self.decoder.decode(b'', final=True))
        if self.line or self.data or self.event:
            raise ValueError('unfinished event')
        if self.state != 'completed':
            raise ValueError('no successful completion')
        return self.text


def softmax(logits):
    if not logits or not all(math.isfinite(x) for x in logits):
        raise ValueError('finite nonempty logits required')
    m = max(logits)
    values = [math.exp(x - m) for x in logits]
    return [v / sum(values) for v in values]


def decode(raw, width):
    s = Stream()
    for start in range(0, len(raw), width):
        s.feed(raw[start:start+width])
    return s.finish()


def must_fail(raw):
    try:
        decode(raw, 1)
    except (ValueError, UnicodeDecodeError):
        return
    raise AssertionError('invalid stream accepted')


if __name__ == '__main__':
    text = 'Pending：GPU 不足'
    wire = (': heartbeat\n\nevent: delta\ndata: ' +
            json.dumps({'text': text}, ensure_ascii=False) +
            '\n\nevent: done\ndata: {"reason":"stop"}\n\n')
    raw = wire.encode()
    for newline in ['\n', '\r\n', '\r']:
        variant = b'\xef\xbb\xbf' + wire.replace('\n', newline).encode()
        for width in range(1, len(variant)+1):
            assert decode(variant, width) == text
    must_fail(raw.split(b'event: done')[0])
    must_fail(raw[:-1])
    must_fail(b'event: error\ndata: {"error":"overloaded"}\n\n')
    must_fail(b'event: delta\ndata: {bad}\n\n')
    must_fail(b'event: delta\ndata: {"text":3}\n\n')
    must_fail(b'\xff')
    must_fail(raw + b'event: delta\ndata: {"text":"late"}\n\n')
    try:
        Stream(max_event=4).feed(b'data: oversized')
    except ValueError:
        pass
    else:
        raise AssertionError('size limit failed')
    p = softmax([2,1,0])
    assert abs(sum(p)-1) < 1e-12
    assert all(abs(a-b)<1e-12 for a,b in zip(p,softmax([1002,1001,1000])))
    kv = 2*32*1*8192*8*128*2
    assert kv == 1024**3
    cost = (2000*2+500*8)/1e6
    assert abs(cost-0.008) < 1e-12
    print(text)
    print('softmax:', ', '.join(f'{x:.4f}' for x in p))
    print(f'KV: {kv/1024**3:.1f} GiB; hypothetical cost: ${cost:.3f}')
    print('PASS: byte fragmentation, newline variants, truncation, errors, bounds and arithmetic')
