inspect-ai 0.3.72__py3-none-any.whl → 0.3.73__py3-none-any.whl

inspect_ai/_view/www/node_modules/flatted/python/flatted.py

@@ -1,149 +0,0 @@
-# ISC License
-#
-# Copyright (c) 2018-2021, Andrea Giammarchi, @WebReflection
-#
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-# PERFORMANCE OF THIS SOFTWARE.
-
-import json as _json
-
-class _Known:
-    def __init__(self):
-        self.key = []
-        self.value = []
-
-class _String:
-    def __init__(self, value):
-        self.value = value
-
-
-def _array_keys(value):
-    keys = []
-    i = 0
-    for _ in value:
-        keys.append(i)
-        i += 1
-    return keys
-
-def _object_keys(value):
-    keys = []
-    for key in value:
-        keys.append(key)
-    return keys
-
-def _is_array(value):
-    return isinstance(value, list) or isinstance(value, tuple)
-
-def _is_object(value):
-    return isinstance(value, dict)
-
-def _is_string(value):
-    return isinstance(value, str)
-
-def _index(known, input, value):
-    input.append(value)
-    index = str(len(input) - 1)
-    known.key.append(value)
-    known.value.append(index)
-    return index
-
-def _loop(keys, input, known, output):
-    for key in keys:
-        value = output[key]
-        if isinstance(value, _String):
-            _ref(key, input[int(value.value)], input, known, output)
-
-    return output
-
-def _ref(key, value, input, known, output):
-    if _is_array(value) and not value in known:
-        known.append(value)
-        value = _loop(_array_keys(value), input, known, value)
-    elif _is_object(value) and not value in known:
-        known.append(value)
-        value = _loop(_object_keys(value), input, known, value)
-
-    output[key] = value
-
-def _relate(known, input, value):
-    if _is_string(value) or _is_array(value) or _is_object(value):
-        try:
-            return known.value[known.key.index(value)]
-        except:
-            return _index(known, input, value)
-
-    return value
-
-def _transform(known, input, value):
-    if _is_array(value):
-        output = []
-        for val in value:
-            output.append(_relate(known, input, val))
-        return output
-
-    if _is_object(value):
-        obj = {}
-        for key in value:
-            obj[key] = _relate(known, input, value[key])
-        return obj
-
-    return value
-
-def _wrap(value):
-    if _is_string(value):
-        return _String(value)
-
-    if _is_array(value):
-        i = 0
-        for val in value:
-            value[i] = _wrap(val)
-            i += 1
-
-    elif _is_object(value):
-        for key in value:
-            value[key] = _wrap(value[key])
-
-    return value
-
-def parse(value, *args, **kwargs):
-    json = _json.loads(value, *args, **kwargs)
-    wrapped = []
-    for value in json:
-        wrapped.append(_wrap(value))
-
-    input = []
-    for value in wrapped:
-        if isinstance(value, _String):
-            input.append(value.value)
-        else:
-            input.append(value)
-
-    value = input[0]
-
-    if _is_array(value):
-        return _loop(_array_keys(value), input, [value], value)
-
-    if _is_object(value):
-        return _loop(_object_keys(value), input, [value], value)
-
-    return value
-
-
-def stringify(value, *args, **kwargs):
-    known = _Known()
-    input = []
-    output = []
-    i = int(_index(known, input, value))
-    while i < len(input):
-        output.append(_transform(known, input, input[i]))
-        i += 1
-    return _json.dumps(output, *args, **kwargs)

inspect_ai/_view/www/node_modules/flatted/python/test.py

@@ -1,63 +0,0 @@
-from flatted import stringify as _stringify, parse
-
-def stringify(value):
-    return _stringify(value, separators=(',', ':'))
-
-assert stringify([None, None]) == '[[null,null]]'
-
-a = []
-o = {}
-
-assert stringify(a) == '[[]]'
-assert stringify(o) == '[{}]'
-
-a.append(a)
-o['o'] = o
-
-assert stringify(a) == '[["0"]]'
-assert stringify(o) == '[{"o":"0"}]'
-
-b = parse(stringify(a))
-assert isinstance(b, list) and b[0] == b
-
-a.append(1)
-a.append('two')
-a.append(True)
-o['one'] = 1
-o['two'] = 'two'
-o['three'] = True
-
-assert stringify(a) == '[["0",1,"1",true],"two"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true},"two"]'
-
-a.append(o)
-o['a'] = a
-
-assert stringify(a) == '[["0",1,"1",true,"2"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0"}]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2"},"two",["2",1,"1",true,"0"]]'
-
-a.append({'test': 'OK'})
-a.append([1, 2, 3])
-
-o['test'] = {'test': 'OK'}
-o['array'] = [1, 2, 3]
-
-assert stringify(a) == '[["0",1,"1",true,"2","3","4"],"two",{"o":"2","one":1,"two":"1","three":true,"a":"0","test":"3","array":"4"},{"test":"5"},[1,2,3],"OK"]'
-assert stringify(o) == '[{"o":"0","one":1,"two":"1","three":true,"a":"2","test":"3","array":"4"},"two",["2",1,"1",true,"0","3","4"],{"test":"5"},[1,2,3],"OK"]'
-
-a2 = parse(stringify(a));
-o2 = parse(stringify(o));
-
-assert a2[0] == a2
-assert o2['o'] == o2
-
-assert a2[1] == 1 and a2[2] == 'two' and a2[3] == True and isinstance(a2[4], dict)
-assert a2[4] == a2[4]['o'] and a2 == a2[4]['o']['a']
-
-str = parse('[{"prop":"1","a":"2","b":"3"},{"value":123},["4","5"],{"e":"6","t":"7","p":4},{},{"b":"8"},"f",{"a":"9"},["10"],"sup",{"a":1,"d":2,"c":"7","z":"11","h":1},{"g":2,"a":"7","b":"12","f":6},{"r":4,"u":"7","c":5}]')
-assert str['b']['t']['a'] == 'sup' and str['a'][1]['b'][0]['c'] == str['b']['t']
-
-oo = parse('[{"a":"1","b":"0","c":"2"},{"aa":"3"},{"ca":"4","cb":"5","cc":"6","cd":"7","ce":"8","cf":"9"},{"aaa":"10"},{"caa":"4"},{"cba":"5"},{"cca":"2"},{"cda":"4"},"value2","value3","value1"]');
-assert oo['a']['aa']['aaa'] == 'value1' and oo == oo['b'] and oo['c']['ca']['caa'] == oo['c']['ca']
-
-print('OK')

inspect_ai/model/_providers/util/tracker.py

@@ -1,92 +0,0 @@
-import re
-import time
-from typing import Any, cast
-
-import httpx
-from shortuuid import uuid
-
-
-class HttpTimeTracker:
-    def __init__(self) -> None:
-        # track request start times
-        self._requests: dict[str, float] = {}
-
-    def start_request(self) -> str:
-        request_id = uuid()
-        self._requests[request_id] = time.monotonic()
-        return request_id
-
-    def end_request(self, request_id: str) -> float:
-        # read the request time if (if available) and purge from dict
-        request_time = self._requests.pop(request_id, None)
-        if request_time is None:
-            raise RuntimeError(f"request_id not registered: {request_id}")
-
-        # return elapsed time
-        return time.monotonic() - request_time
-
-    def update_request_time(self, request_id: str) -> None:
-        request_time = self._requests.get(request_id, None)
-        if not request_time:
-            raise RuntimeError(f"No request registered for request_id: {request_id}")
-
-        # update the request time
-        self._requests[request_id] = time.monotonic()
-
-
-class BotoTimeTracker(HttpTimeTracker):
-    def __init__(self, session: Any) -> None:
-        from aiobotocore.session import AioSession
-
-        super().__init__()
-
-        # register hook
-        session = cast(AioSession, session._session)
-        session.register(
-            "before-send.bedrock-runtime.Converse", self.converse_before_send
-        )
-
-    def converse_before_send(self, **kwargs: Any) -> None:
-        user_agent = kwargs["request"].headers["User-Agent"].decode()
-        match = re.search(rf"{self.USER_AGENT_PREFIX}(\w+)", user_agent)
-        if match:
-            request_id = match.group(1)
-            self.update_request_time(request_id)
-
-    def user_agent_extra(self, request_id: str) -> str:
-        return f"{self.USER_AGENT_PREFIX}{request_id}"
-
-    USER_AGENT_PREFIX = "ins/rid#"
-
-
-class HttpxTimeTracker(HttpTimeTracker):
-    """Class which tracks the duration of successful (200 status) http requests.
-
-    A special header is injected into requests which is then read from
-    an httpx 'request' event hook -- this creates a record of when the request
-    started. Note that with retries a single request id could be started
-    several times; our request hook makes sure we always track the time of
-    the last request.
-
-    To determine the total time, we also install an httpx response hook. In
-    this hook we look for 200 responses which have a registered request id.
-    When we find one, we update the end time of the request.
-
-    There is an 'end_request()' method which gets the total requeset time
-    for a request_id and then purges the request_id from our tracking (so
-    the dict doesn't grow unbounded)
-    """
-
-    REQUEST_ID_HEADER = "x-irid"
-
-    def __init__(self, client: httpx.AsyncClient):
-        super().__init__()
-
-        # install httpx request hook
-        client.event_hooks["request"].append(self.request_hook)
-
-    async def request_hook(self, request: httpx.Request) -> None:
-        # update the last request time for this request id (as there could be retries)
-        request_id = request.headers.get(self.REQUEST_ID_HEADER, None)
-        if request_id:
-            self.update_request_time(request_id)