@qvac/harness 0.2.12 → 0.3.1

package/dist-lib/lib/models/nmt-catalog.js

@@ -0,0 +1,166 @@
+export const ENGLISH = 'en';
+const TO_ENGLISH = [
+    'ar',
+    'az',
+    'be',
+    'bg',
+    'bn',
+    'bs',
+    'ca',
+    'cs',
+    'da',
+    'de',
+    'el',
+    'es',
+    'et',
+    'fa',
+    'fi',
+    'fr',
+    'gu',
+    'he',
+    'hi',
+    'hr',
+    'hu',
+    'id',
+    'is',
+    'it',
+    'ja',
+    'kn',
+    'ko',
+    'lt',
+    'lv',
+    'ml',
+    'ms',
+    'mt',
+    'nb',
+    'nl',
+    'nn',
+    'no',
+    'pl',
+    'pt',
+    'ro',
+    'ru',
+    'sk',
+    'sl',
+    'sq',
+    'sr',
+    'sv',
+    'ta',
+    'te',
+    'th',
+    'tr',
+    'uk',
+    'vi',
+    'zh'
+];
+const FROM_ENGLISH = TO_ENGLISH.filter((code) => !['be', 'mt', 'nn'].includes(code));
+export const NMT_TO_ENGLISH = TO_ENGLISH;
+export const NMT_FROM_ENGLISH = FROM_ENGLISH;
+const SLM_LANGUAGES = [
+    { iso: 'af', flores: 'afr_Latn', name: 'Afrikaans' },
+    { iso: 'am', flores: 'amh_Ethi', name: 'Amharic' },
+    { iso: 'ha', flores: 'hau_Latn', name: 'Hausa' },
+    { iso: 'ig', flores: 'ibo_Latn', name: 'Igbo' },
+    { iso: 'rw', flores: 'kin_Latn', name: 'Kinyarwanda' },
+    { iso: 'mg', flores: 'plt_Latn', name: 'Malagasy' },
+    { iso: 'ny', flores: 'nya_Latn', name: 'Nyanja' },
+    { iso: 'om', flores: 'gaz_Latn', name: 'Oromo' },
+    { iso: 'sn', flores: 'sna_Latn', name: 'Shona' },
+    { iso: 'so', flores: 'som_Latn', name: 'Somali' },
+    { iso: 'st', flores: 'sot_Latn', name: 'Southern Sotho' },
+    { iso: 'sw', flores: 'swh_Latn', name: 'Swahili' },
+    { iso: 'tn', flores: 'tsn_Latn', name: 'Tswana' },
+    { iso: 'xh', flores: 'xho_Latn', name: 'Xhosa' },
+    { iso: 'yo', flores: 'yor_Latn', name: 'Yoruba' },
+    { iso: 'zu', flores: 'zul_Latn', name: 'Zulu' }
+];
+export const SLM_MODEL = 'TranslatePsy-AfriSLM-0.8B-Q4_K_M-imat';
+export function isTranslationModel(model) {
+    return /(^|[/\\])TranslatePsy-/.test(model);
+}
+const EURONANO = 'https://huggingface.co/qvac/TranslatePsy-EuroNano/resolve/main';
+const EURONANO_SIZE = 'Base';
+export const EURONANO_LANGUAGES = [
+    'cs',
+    'de',
+    'es',
+    'fi',
+    'fr',
+    'it',
+    'nl',
+    'pt',
+    'sv'
+];
+function euroNanoPack(direction) {
+    const dir = `${EURONANO}/${direction}/${EURONANO_SIZE}/intgemm`;
+    return { model: `${dir}/model.intgemm.alphas.bin`, vocab: `${dir}/vocab.spm` };
+}
+export const SLM_LANGUAGE_CODES = SLM_LANGUAGES.map((entry) => entry.iso);
+export function languageLabel(code) {
+    const wanted = code.toLowerCase();
+    return SLM_LANGUAGES.find((entry) => entry.flores.toLowerCase() === wanted || entry.iso === wanted)?.name;
+}
+export const SLM_LANGUAGE_NAMES = SLM_LANGUAGES.map(({ iso, name }) => ({ code: iso, name }));
+export function slmLanguage(code) {
+    const wanted = code.toLowerCase();
+    return SLM_LANGUAGES.find((entry) => entry.flores.toLowerCase() === wanted || entry.iso === wanted)?.flores;
+}
+const modelFilter = (pair) => `model.${pair}.intgemm`;
+export function sameLanguage(from, to) {
+    return canonical(from) === canonical(to);
+}
+function canonical(code) {
+    return slmLanguage(code) ?? code.toLowerCase();
+}
+export function translationPlanFor(requestedFrom, requestedTo) {
+    const from = requestedFrom.toLowerCase();
+    const to = requestedTo.toLowerCase();
+    if (sameLanguage(from, to))
+        return { error: `${from} is already the target language` };
+    const slmFrom = slmLanguage(from);
+    const slmTo = slmLanguage(to);
+    if (slmFrom || slmTo) {
+        return { route: 'slm', from: slmFrom ?? from, to: slmTo ?? to, model: SLM_MODEL };
+    }
+    if (to === ENGLISH && EURONANO_LANGUAGES.includes(from)) {
+        const pack = euroNanoPack('xx-en');
+        return {
+            route: 'nmt',
+            from,
+            to,
+            model: pack.model,
+            srcVocab: pack.vocab,
+            dstVocab: pack.vocab
+        };
+    }
+    if (from === ENGLISH && EURONANO_LANGUAGES.includes(to)) {
+        const pack = euroNanoPack('en-xx');
+        return {
+            route: 'nmt',
+            from,
+            to,
+            model: pack.model,
+            srcVocab: pack.vocab,
+            dstVocab: pack.vocab,
+            tag: `##${to.toUpperCase()}`
+        };
+    }
+    if (to === ENGLISH) {
+        if (!TO_ENGLISH.includes(from))
+            return { error: `cannot translate from ${from}` };
+        return { route: 'nmt', from, to, model: modelFilter(`${from}${ENGLISH}`) };
+    }
+    if (!FROM_ENGLISH.includes(to))
+        return { error: `cannot translate to ${to}` };
+    if (from === ENGLISH)
+        return { route: 'nmt', from, to, model: modelFilter(`${ENGLISH}${to}`) };
+    if (!TO_ENGLISH.includes(from))
+        return { error: `cannot translate from ${from}` };
+    return {
+        route: 'nmt',
+        from,
+        to,
+        model: modelFilter(`${from}${ENGLISH}`),
+        pivot: modelFilter(`${ENGLISH}${to}`)
+    };
+}

package/dist-lib/lib/no-redirect-fetch-impl.d.ts

@@ -1,6 +1,6 @@
 export interface FetchRequestLike {
     on(event: 'error', listener: (err: Error) => void): void;
-    write(chunk: string): void;
+    write(chunk: string | Uint8Array): void;
     end(): void;
     destroy(err?: Error): void;
 }
@@ -19,7 +19,7 @@ export type BareRequestFn<Response extends FetchResponseLike = FetchResponseLike
 export interface NoRedirectFetchInit {
     method?: string;
     headers?: Record<string, string>;
-    body?: string;
+    body?: string | Uint8Array;
     signal?: {
         readonly aborted: boolean;
         addEventListener(type: 'abort', listener: () => void): void;
@@ -32,6 +32,7 @@ export interface NoRedirectFetchResponse {
     status: number;
     headers: {
         get(name: string): string | null;
+        entries(): [string, string][];
     };
     text(): string;
     bytes(): Uint8Array;

package/dist-lib/lib/no-redirect-fetch-impl.js

@@ -29,7 +29,10 @@ export function runNoRedirectFetch(request, url, init = {}) {
                 }
                 resolve({
                     status: res.statusCode,
-                    headers: { get: (name) => responseHeaders[name.toLowerCase()] ?? null },
+                    headers: {
+                        get: (name) => responseHeaders[name.toLowerCase()] ?? null,
+                        entries: () => Object.entries(responseHeaders)
+                    },
                     text: () => b4a.toString(body, 'utf8'),
                     bytes: () => body
                 });

package/dist-lib/lib/serve.js

@@ -296,6 +296,7 @@ function runFrame(harness, frame, context) {
     return harness.invoke({
         capability,
         args: frame.arguments ?? {},
+        enhance: frame.enhance === 'auto' ? 'auto' : 'never',
         agent: frame.agent ?? undefined,
         attach: context.attach,
         fetchAttachment: context.fetchAttachment,

package/dist-lib/lib/tools/exec/adapters/adapter.d.ts

@@ -15,6 +15,8 @@ export type ExecutionContext = {
         path: string;
     }[];
     readonly runBudget?: RunBudget;
+    readonly sandboxMode?: boolean;
+    readonly toolNames?: readonly string[];
 };
 export type ExecutionPlan = {
     run(options: ExecutionOptions): Promise<ExecResult> | ExecResult;

package/dist-lib/lib/tools/exec/adapters/python/distributions.d.ts

@@ -0,0 +1 @@
+export declare function moduleDistribution(module: string): string | null;

package/dist-lib/lib/tools/exec/adapters/python/distributions.js

@@ -0,0 +1,4 @@
+import { MODULE_DISTRIBUTIONS } from './module-distributions.js';
+export function moduleDistribution(module) {
+    return Object.hasOwn(MODULE_DISTRIBUTIONS, module) ? (MODULE_DISTRIBUTIONS[module] ?? null) : null;
+}

package/dist-lib/lib/tools/exec/adapters/python/guarded-fetch.d.ts

@@ -0,0 +1,67 @@
+import { type HostResolver } from '../../../url-guard.ts';
+import type { NoRedirectFetchInit, NoRedirectFetchResponse } from '../../../../no-redirect-fetch-impl.ts';
+export declare const MAX_RESPONSE_BYTES: number;
+type NoRedirectFetch = (url: URL, init?: NoRedirectFetchInit) => Promise<NoRedirectFetchResponse>;
+declare const GUARDED: unique symbol;
+export declare function isGuardedFetch(fetch: unknown): boolean;
+type SignalLike = {
+    readonly aborted: boolean;
+    addEventListener(type: 'abort', listener: () => void): void;
+};
+type FetchInit = {
+    method?: string;
+    headers?: unknown;
+    body?: unknown;
+    signal?: SignalLike | null;
+    redirect?: string;
+};
+export type GuardedFetchOptions = {
+    readonly fetch?: NoRedirectFetch;
+    readonly resolveHost?: HostResolver;
+    readonly maxBytes?: number;
+    readonly timeoutMs?: number;
+};
+declare class GuardedHeaders {
+    #private;
+    constructor(entries: [string, string][]);
+    get(name: string): string | null;
+    has(name: string): boolean;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    forEach(fn: (value: string, key: string) => void): void;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+export declare class GuardedResponse {
+    #private;
+    readonly type = "basic";
+    readonly statusText = "";
+    readonly status: number;
+    readonly headers: GuardedHeaders;
+    readonly url: string;
+    readonly redirected: boolean;
+    constructor(status: number, headers: [string, string][], bytes: Uint8Array, url: string, redirected: boolean);
+    get ok(): boolean;
+    get bodyUsed(): boolean;
+    get body(): {
+        getReader(): {
+            read(): Promise<{
+                done: boolean;
+                value?: Uint8Array;
+            }>;
+            cancel(): Promise<void>;
+            releaseLock(): void;
+        };
+    };
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    clone(): GuardedResponse;
+}
+export declare function createGuardedFetch(options?: GuardedFetchOptions): ((input: string | URL | {
+    url: string;
+}, init?: FetchInit) => Promise<GuardedResponse>) & {
+    [GUARDED]: true;
+};
+export {};

package/dist-lib/lib/tools/exec/adapters/python/guarded-fetch.js

@@ -0,0 +1,196 @@
+import { AbortController } from 'bare-abort-controller';
+import b4a from 'b4a';
+import defaultFetch from '#no-redirect-fetch';
+import { lookupHost } from '../../../../dns-lookup.js';
+import { resolveOutboundUrl } from '../../../url-guard.js';
+export const MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
+const MAX_REDIRECTS = 10;
+const TIMEOUT_MS = 120_000;
+const CHUNK_BYTES = 1024 * 1024;
+const GUARDED = Symbol.for('qvac.harness.guardedFetch');
+export function isGuardedFetch(fetch) {
+    return typeof fetch === 'function' && fetch[GUARDED] === true;
+}
+function isRedirect(status) {
+    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function headerRecord(headers) {
+    const out = {};
+    if (!headers || typeof headers !== 'object')
+        return out;
+    const pairs = Array.isArray(headers)
+        ? headers
+        : typeof headers.entries === 'function'
+            ? headers.entries()
+            : Object.entries(headers);
+    for (const pair of pairs) {
+        if (!Array.isArray(pair) || pair.length < 2)
+            continue;
+        out[String(pair[0])] = String(pair[1]);
+    }
+    return out;
+}
+function bodyBytes(body) {
+    if (body === undefined || body === null)
+        return undefined;
+    if (typeof body === 'string')
+        return body;
+    if (body instanceof ArrayBuffer)
+        return new Uint8Array(body);
+    if (ArrayBuffer.isView(body))
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    return String(body);
+}
+function plain(bytes) {
+    return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+class GuardedHeaders {
+    #map;
+    constructor(entries) {
+        this.#map = new Map(entries.map(([k, v]) => [k.toLowerCase(), v]));
+    }
+    get(name) {
+        return this.#map.get(name.toLowerCase()) ?? null;
+    }
+    has(name) {
+        return this.#map.has(name.toLowerCase());
+    }
+    entries() {
+        return this.#map.entries();
+    }
+    keys() {
+        return this.#map.keys();
+    }
+    values() {
+        return this.#map.values();
+    }
+    forEach(fn) {
+        this.#map.forEach((value, key) => fn(value, key));
+    }
+    [Symbol.iterator]() {
+        return this.#map.entries();
+    }
+}
+export class GuardedResponse {
+    type = 'basic';
+    statusText = '';
+    status;
+    headers;
+    url;
+    redirected;
+    #bytes;
+    #used = false;
+    constructor(status, headers, bytes, url, redirected) {
+        this.status = status;
+        this.headers = new GuardedHeaders(headers);
+        this.#bytes = bytes;
+        this.url = url;
+        this.redirected = redirected;
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    get bodyUsed() {
+        return this.#used;
+    }
+    get body() {
+        let offset = 0;
+        const bytes = this.#bytes;
+        return {
+            getReader: () => {
+                this.#used = true;
+                return {
+                    read: async () => {
+                        if (offset >= bytes.byteLength)
+                            return { done: true };
+                        const value = plain(bytes.subarray(offset, offset + CHUNK_BYTES));
+                        offset += value.byteLength;
+                        return { done: false, value };
+                    },
+                    cancel: async () => {
+                        offset = bytes.byteLength;
+                    },
+                    releaseLock: () => { }
+                };
+            }
+        };
+    }
+    async arrayBuffer() {
+        this.#used = true;
+        const { buffer, byteOffset, byteLength } = this.#bytes;
+        return buffer.slice(byteOffset, byteOffset + byteLength);
+    }
+    async bytes() {
+        return new Uint8Array(await this.arrayBuffer());
+    }
+    async text() {
+        this.#used = true;
+        return b4a.toString(this.#bytes, 'utf8');
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+    clone() {
+        return new GuardedResponse(this.status, [...this.headers.entries()], this.#bytes, this.url, this.redirected);
+    }
+}
+export function createGuardedFetch(options = {}) {
+    const send = options.fetch ?? defaultFetch;
+    const resolveHost = options.resolveHost ?? lookupHost;
+    const maxBytes = options.maxBytes ?? MAX_RESPONSE_BYTES;
+    const timeoutMs = options.timeoutMs ?? TIMEOUT_MS;
+    const guardedFetch = async function (input, init = {}) {
+        let url = new URL(typeof input === 'string' || input instanceof URL ? input : input.url);
+        let method = (init.method ?? 'GET').toUpperCase();
+        let body = bodyBytes(init.body);
+        const headers = headerRecord(init.headers);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(undefined), timeoutMs);
+        if (init.signal?.aborted)
+            controller.abort(undefined);
+        init.signal?.addEventListener('abort', () => controller.abort(undefined));
+        try {
+            for (let hops = 0;; hops++) {
+                if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                    throw new TypeError(`fetch refused: unsupported protocol ${url.protocol}`);
+                }
+                const check = await resolveOutboundUrl(url, resolveHost, controller.signal);
+                if (check.blocked)
+                    throw new TypeError(`fetch refused: ${check.blocked}`);
+                const response = await send(url, {
+                    method,
+                    headers,
+                    body,
+                    signal: controller.signal,
+                    validatedAddresses: check.addresses,
+                    maxBytes
+                });
+                const location = response.headers.get('location');
+                if (!isRedirect(response.status) || !location || init.redirect === 'manual') {
+                    return new GuardedResponse(response.status, response.headers.entries(), plain(response.bytes()), url.href, hops > 0);
+                }
+                if (init.redirect === 'error')
+                    throw new TypeError('fetch refused: redirect not allowed');
+                if (hops >= MAX_REDIRECTS)
+                    throw new TypeError('fetch refused: too many redirects');
+                const next = new URL(location, url);
+                if (next.protocol !== url.protocol || next.host !== url.host) {
+                    for (const name of Object.keys(headers)) {
+                        if (/^(authorization|cookie)$/i.test(name))
+                            delete headers[name];
+                    }
+                }
+                if (response.status === 303 ||
+                    ((response.status === 301 || response.status === 302) && method === 'POST')) {
+                    method = 'GET';
+                    body = undefined;
+                }
+                url = next;
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    return Object.assign(guardedFetch, { [GUARDED]: true });
+}

package/dist-lib/lib/tools/exec/adapters/python/loader.js

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import b4a from 'b4a';
 import { constants as fsConstants } from 'fs';
 import process from 'process';
+import { createGuardedFetch } from './guarded-fetch.js';
 import { seedPackageCache } from './wheels.js';
 class B4aTextDecoder {
     encoding;
@@ -53,7 +54,7 @@ async function shapeBareGlobals() {
     const g = globalThis;
     if (!g.fetch) {
         const bareFetch = await import('bare-fetch');
-        g.fetch = bareFetch.default;
+        g.fetch = createGuardedFetch();
         g.Request = bareFetch.Request;
         g.Response = bareFetch.Response;
         g.Headers = bareFetch.Headers;

package/dist-lib/lib/tools/exec/adapters/python/module-distributions.d.ts

@@ -0,0 +1 @@
+export declare const MODULE_DISTRIBUTIONS: Readonly<Record<string, string>>;

package/dist-lib/lib/tools/exec/adapters/python/module-distributions.js

@@ -0,0 +1,52 @@
+export const MODULE_DISTRIBUTIONS = {
+    Bio: 'biopython',
+    BioSQL: 'biopython',
+    Crypto: 'pycryptodome',
+    PIL: 'Pillow',
+    PhiSpyModules: 'phispy',
+    PhiSpyRepeatFinder: 'phispy',
+    _argon2_cffi_bindings: 'argon2-cffi-bindings',
+    _distutils_hack: 'setuptools',
+    _pyrsistent_version: 'pyrsistent',
+    _pytest: 'pytest',
+    _yaml: 'pyyaml',
+    _zengl: 'zengl',
+    argon2: 'argon2-cffi',
+    attr: 'attrs',
+    audioop: 'audioop-lts',
+    bigtests: 'screed',
+    bs4: 'beautifulsoup4',
+    cv2: 'opencv-python',
+    cvxpy: 'cvxpy-base',
+    dateutil: 'python-dateutil',
+    dns: 'dnspython',
+    docx: 'python-docx',
+    erfa: 'pyerfa',
+    fitz: 'PyMuPDF',
+    flint: 'python-flint',
+    flirt: 'python-flirt',
+    fpdf: 'fpdf2',
+    google: 'protobuf',
+    gridfs: 'pymongo',
+    isympy: 'sympy',
+    lakers: 'lakers-python',
+    mpl_toolkits: 'matplotlib',
+    mypyc: 'mypy',
+    nacl: 'pynacl',
+    pptx: 'python-pptx',
+    pygame: 'pygame-ce',
+    pylab: 'matplotlib',
+    pysat: 'python-sat',
+    pywt: 'pywavelets',
+    rpds: 'rpds-py',
+    ruamel: 'ruamel.yaml',
+    shapefile: 'pyshp',
+    sisl_toolbox: 'sisl',
+    skimage: 'scikit-image',
+    sklearn: 'scikit-learn',
+    taglib: 'pytaglib',
+    tiktoken_ext: 'tiktoken',
+    tlz: 'toolz',
+    unix_timezones: 'pyodide-unix-timezones',
+    yaml: 'pyyaml'
+};

package/dist-lib/lib/tools/exec/adapters/python/net-shim.d.ts

@@ -0,0 +1,2 @@
+export declare function pythonReachesNetwork(): boolean;
+export declare const NET_SHIM = "\ndef _qvac_install_net():\n    import errno, http.client, io\n    import js\n    from pyodide.ffi import can_run_sync, run_sync, to_js\n\n    if getattr(http.client, '_qvac_net', False):\n        return\n\n    class _Response(http.client.HTTPResponse):\n        # the body is read in full by the fetch, so there is no socket behind it\n        def __init__(self, status, headers, body, url):\n            self.status = self.code = status\n            self.reason = http.client.responses.get(status, '')\n            self.headers = self.msg = http.client.HTTPMessage()\n            for name, value in headers:\n                self.headers[name] = value\n            self.fp = io.BytesIO(body)\n            self.version = 11\n            self.will_close = True\n            self.chunked = False\n            self.length = len(body)\n            self.url = url\n            self.debuglevel = 0\n\n        def read(self, amt=None):\n            return self.fp.read() if amt is None or amt < 0 else self.fp.read(amt)\n\n        def read1(self, n=-1):\n            return self.read(n)\n\n        def readinto(self, b):\n            data = self.fp.read(len(b))\n            b[: len(data)] = data\n            return len(data)\n\n        def peek(self, n=0):\n            pos = self.fp.tell()\n            data = self.fp.read(max(n, 1))\n            self.fp.seek(pos)\n            return data\n\n        def isclosed(self):\n            return self.fp.closed\n\n        def close(self):\n            self.fp.close()\n\n        def fileno(self):\n            raise OSError('this response has no socket')\n\n    class _Connection(http.client.HTTPConnection):\n        scheme = 'http'\n\n        def __init__(self, host, port=None, timeout=None, source_address=None, blocksize=8192, **kw):\n            self.host, self.port, self.timeout = host, port, timeout\n            self.sock = None\n            self.debuglevel = 0\n            self._tunnel_host = None\n            self._request = None\n            self._response = None\n\n        def set_debuglevel(self, level):\n            pass\n\n        def set_tunnel(self, host, port=None, headers=None):\n            self._tunnel_host = host\n\n        def connect(self):\n            pass\n\n        def close(self):\n            pass\n\n        def putrequest(self, method, url, skip_host=False, skip_accept_encoding=False):\n            self._request = [method, url, {}, b'']\n            self._response = None\n\n        def putheader(self, header, *values):\n            self._request[2][header] = ', '.join(str(v) for v in values)\n\n        # A socket connects while the request is sent, so that is where a failure lands and\n        # where urllib turns it into URLError. A body sent after the headers waits for it.\n        def endheaders(self, message_body=None, *, encode_chunked=False):\n            if message_body is not None:\n                self.send(message_body)\n            if message_body is not None or self._request[0] in ('GET', 'HEAD', 'DELETE', 'OPTIONS'):\n                self._response = self._fetch()\n\n        def send(self, data):\n            if hasattr(data, 'read'):\n                data = data.read()\n            if isinstance(data, str):\n                data = data.encode()\n            self._request[3] += bytes(data)\n\n        def request(self, method, url, body=None, headers={}, *, encode_chunked=False):\n            self.putrequest(method, url)\n            for name, value in dict(headers).items():\n                self.putheader(name, value)\n            self.endheaders(body)\n\n        def getresponse(self):\n            response = self._response or self._fetch()\n            self._response = None\n            return response\n\n        def _fetch(self):\n            method, url, headers, body = self._request\n            if not url.startswith(('http://', 'https://')):\n                port = '' if self.port in (None, self.default_port) else ':%d' % self.port\n                url = '%s://%s%s%s' % (self.scheme, self.host, port, url)\n            if not can_run_sync():\n                raise OSError(errno.EHOSTUNREACH, 'Host is unreachable')\n            # the fetch hands back decoded bytes, so no encoding is asked for and none reported\n            skip = ('accept-encoding', 'connection', 'host', 'content-length')\n            headers = {k: v for k, v in headers.items() if k.lower() not in skip}\n            headers['Accept-Encoding'] = 'identity'\n            init = {'method': method, 'headers': headers, 'redirect': 'manual'}\n            if body:\n                init['body'] = to_js(body)\n            try:\n                response = run_sync(js.fetch(url, to_js(init, dict_converter=js.Object.fromEntries)))\n                data = bytes(run_sync(response.arrayBuffer()).to_py())\n            except Exception as error:\n                # the guard's own refusal, or the transport's: either says more than an errno\n                raise OSError(getattr(error, 'message', None) or str(error)) from None\n            entries = [(str(k), str(v)) for k, v in response.headers.entries()]\n            drop = ('content-encoding', 'transfer-encoding', 'content-length')\n            kept = [(k, v) for k, v in entries if k.lower() not in drop]\n            kept.append(('Content-Length', str(len(data))))\n            return _Response(int(response.status), kept, data, url)\n\n    class _HTTPSConnection(_Connection):\n        scheme = 'https'\n        default_port = 443\n\n    http.client.HTTPConnection = _Connection\n    http.client.HTTPSConnection = _HTTPSConnection\n    http.client._qvac_net = True\n\n_qvac_install_net()\ndel _qvac_install_net\n";