공개 HTML의 정상·불일치·검사 불가를 구별한다

python -X utf8 publication_probe.py PUBLIC_URL --contains "게시글 제목" --contains "본문의 고유한 문장"

"""A new public HTML probe. It does not publish, authenticate or verify source truth."""
import argparse
import json
from html.parser import HTMLParser
from urllib.error import HTTPError, URLError
from urllib.parse import urlsplit
from urllib.request import HTTPRedirectHandler, ProxyHandler, Request, build_opener

MAX_BYTES=1024*1024

class DocumentText(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True);self.skip=0;self.chunks=[]
    def handle_starttag(self,tag,attrs):
        if tag in ['script','style','title']:self.skip+=1
    def handle_endtag(self,tag):
        if tag in ['script','style','title'] and self.skip:self.skip-=1
    def handle_data(self,value):
        if not self.skip:self.chunks.append(value)
    def text(self):return ' '.join(' '.join(self.chunks).split())

def inspect_response(status, content_type, body, markers, max_bytes=MAX_BYTES):
    if not isinstance(markers,(list,tuple)) or not markers or any(not isinstance(m,str) or not m.strip() for m in markers):
        raise ValueError('Provide at least one nonempty expected text marker')
    if not isinstance(max_bytes,int) or max_bytes<1:raise ValueError('Invalid body-size limit')
    if not isinstance(body,bytes):raise TypeError('Response body must be bytes')
    result={'state':'unverified','http_status':status,'reason':'','missing_indices':[],'bytes_read':len(body)}
    if status==404:result.update(state='missing',reason='Page not found');return result
    if status!=200:result['reason']='Unexpected HTTP response';return result
    if len(body)>max_bytes:result['reason']='Body exceeds the inspection limit';return result
    if str(content_type).split(';',1)[0].strip().lower() not in ['text/html','application/xhtml+xml']:
        result['reason']='Expected an HTML response';return result
    try:text=body.decode('utf-8')
    except UnicodeDecodeError:result['reason']='Response is not valid UTF-8';return result
    parser=DocumentText();parser.feed(text);document=parser.text()
    missing=[i for i,marker in enumerate(markers) if ' '.join(marker.split()) not in document]
    if missing:result.update(state='mismatch',reason='Expected text is absent',missing_indices=missing);return result
    result.update(state='passed',reason='HTTP and expected server-document text matched');return result

class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self,request,fp,code,message,headers,newurl):return None

def probe(url,markers,timeout=10,max_bytes=MAX_BYTES):
    # Validate the comparison contract before making a network request.
    inspect_response(0,'',b'',markers,max_bytes)
    parsed=urlsplit(url)
    if parsed.scheme not in ['http','https'] or not parsed.hostname or parsed.username or parsed.password:
        raise ValueError('Use a public HTTP(S) address without embedded credentials')
    opener=build_opener(ProxyHandler({}),NoRedirect())
    request=Request(url,headers={'User-Agent':'Public-HTML-Probe/1.0'},method='GET')
    try:
        with opener.open(request,timeout=timeout) as response:
            status=response.status;kind=response.headers.get('Content-Type','');body=response.read(max_bytes+1)
    except HTTPError as error:
        with error:
            status=error.code;kind=error.headers.get('Content-Type','');body=error.read(max_bytes+1)
    except (URLError,OSError,TimeoutError) as error:
        return {'state':'unverified','http_status':None,'reason':'Transport failure: '+type(error).__name__,'missing_indices':[],'bytes_read':0}
    return inspect_response(status,kind,body,markers,max_bytes)

def exit_code(result):
    return 0 if result['state']=='passed' else 1 if result['state'] in ['missing','mismatch'] else 2

def main():
    parser=argparse.ArgumentParser(description='Check one public HTML response and explicit expected text. No writes.')
    parser.add_argument('url');parser.add_argument('--contains',action='append',required=True)
    parser.add_argument('--timeout',type=float,default=10);parser.add_argument('--max-bytes',type=int,default=MAX_BYTES)
    args=parser.parse_args()
    if args.timeout<=0:parser.error('Timeout must be positive')
    try:result=probe(args.url,args.contains,args.timeout,args.max_bytes)
    except (ValueError,TypeError) as error:parser.error(str(error))
    print(json.dumps(result,ensure_ascii=False))
    return exit_code(result)

if __name__=='__main__':raise SystemExit(main())