toolslm 0.0.5__tar.gz → 0.3.13__tar.gz

toolslm-0.3.13/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: toolslm
+Version: 0.3.13
+Summary: Tools to make language models a bit easier to use
+Home-page: https://github.com/AnswerDotAI/toolslm
+Author: Jeremy Howard
+Author-email: j@fast.ai
+License: Apache Software License 2.0
+Keywords: nbdev jupyter notebook python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastcore>=1.9.7
+Requires-Dist: httpx
+Provides-Extra: dev
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# toolslm
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This is a work in progress…
+
+## Install
+
+``` sh
+pip install toolslm
+```
+
+## How to use
+
+### Context creation
+
+toolslm has some helpers to make it easier to generate XML context from
+files, for instance
+[`folder2ctx`](https://AnswerDotAI.github.io/toolslm/xml.html#folder2ctx):
+
+``` python
+print(folder2ctx('samples', prefix=False, file_glob='*.py'))
+```
+
+    <documents><document index="1"><src>
+    samples/sample_core.py
+    </src><document-content>
+    import inspect
+    empty = inspect.Parameter.empty
+    models = 'claude-3-opus-20240229','claude-3-sonnet-20240229','claude-3-haiku-20240307'
+    </document-content></document></documents>
+
+JSON doesn’t map as nicely to XML as the `ft` data structure from
+`fastcore.xml`, but for simple XML trees it can be convenient. The
+[`json_to_xml`](https://AnswerDotAI.github.io/toolslm/xml.html#json_to_xml)
+function handles that conversion:
+
+``` python
+a = dict(surname='Howard', firstnames=['Jeremy','Peter'],
+         address=dict(state='Queensland',country='Australia'))
+print(json_to_xml(a, 'person'))
+```
+
+    <person>
+      <surname>Howard</surname>
+      <firstnames>
+        <item>Jeremy</item>
+        <item>Peter</item>
+      </firstnames>
+      <address>
+        <state>Queensland</state>
+        <country>Australia</country>
+      </address>
+    </person>

toolslm-0.3.13/README.md

@@ -0,0 +1,55 @@
+# toolslm
+
+
+<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
+
+This is a work in progress…
+
+## Install
+
+``` sh
+pip install toolslm
+```
+
+## How to use
+
+### Context creation
+
+toolslm has some helpers to make it easier to generate XML context from
+files, for instance
+[`folder2ctx`](https://AnswerDotAI.github.io/toolslm/xml.html#folder2ctx):
+
+``` python
+print(folder2ctx('samples', prefix=False, file_glob='*.py'))
+```
+
+    <documents><document index="1"><src>
+    samples/sample_core.py
+    </src><document-content>
+    import inspect
+    empty = inspect.Parameter.empty
+    models = 'claude-3-opus-20240229','claude-3-sonnet-20240229','claude-3-haiku-20240307'
+    </document-content></document></documents>
+
+JSON doesn’t map as nicely to XML as the `ft` data structure from
+`fastcore.xml`, but for simple XML trees it can be convenient. The
+[`json_to_xml`](https://AnswerDotAI.github.io/toolslm/xml.html#json_to_xml)
+function handles that conversion:
+
+``` python
+a = dict(surname='Howard', firstnames=['Jeremy','Peter'],
+         address=dict(state='Queensland',country='Australia'))
+print(json_to_xml(a, 'person'))
+```
+
+    <person>
+      <surname>Howard</surname>
+      <firstnames>
+        <item>Jeremy</item>
+        <item>Peter</item>
+      </firstnames>
+      <address>
+        <state>Queensland</state>
+        <country>Australia</country>
+      </address>
+    </person>

toolslm-0.3.13/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=64.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name="toolslm"
+requires-python=">=3.9"
+dynamic = [ "keywords", "description", "version", "dependencies", "optional-dependencies", "readme", "license", "authors", "classifiers", "entry-points", "scripts", "urls"]
+
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "settings.ini" }, { file = "setup.py" }]

{toolslm-0.0.5 → toolslm-0.3.13}/settings.ini

@@ -1,11 +1,11 @@
 [DEFAULT]
 repo = toolslm
 lib_name = toolslm
-version = 0.0.5
+version = 0.3.13
 min_python = 3.9
 license = apache2
 black_formatting = False
-requirements = fastcore>=1.5.47
+requirements = fastcore>=1.9.7 httpx
 doc_path = _docs
 lib_path = toolslm
 nbs_path = .
@@ -35,5 +35,7 @@ clean_ids = True
 clear_all = False
 conda_user = fastai
 console_scripts = folder2ctx=toolslm.xml:folder2ctx_cli
-cell_number = True
+cell_number = False
+skip_procs = 
+update_pyproject = True
 

toolslm-0.3.13/toolslm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.13"

toolslm-0.3.13/toolslm/_modidx.py

@@ -0,0 +1,54 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/toolslm',
+                'doc_host': 'https://AnswerDotAI.github.io',
+                'git_url': 'https://github.com/AnswerDotAI/toolslm',
+                'lib_path': 'toolslm'},
+  'syms': { 'toolslm.download': { 'toolslm.download._tryget': ('download.html#_tryget', 'toolslm/download.py'),
+                                  'toolslm.download.clean_md': ('download.html#clean_md', 'toolslm/download.py'),
+                                  'toolslm.download.find_docs': ('download.html#find_docs', 'toolslm/download.py'),
+                                  'toolslm.download.get_llmstxt': ('download.html#get_llmstxt', 'toolslm/download.py'),
+                                  'toolslm.download.html2md': ('download.html#html2md', 'toolslm/download.py'),
+                                  'toolslm.download.read_docs': ('download.html#read_docs', 'toolslm/download.py'),
+                                  'toolslm.download.read_html': ('download.html#read_html', 'toolslm/download.py'),
+                                  'toolslm.download.read_md': ('download.html#read_md', 'toolslm/download.py'),
+                                  'toolslm.download.split_url': ('download.html#split_url', 'toolslm/download.py')},
+            'toolslm.funccall': { 'toolslm.funccall._coerce_inputs': ('funccall.html#_coerce_inputs', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._copy_loc': ('funccall.html#_copy_loc', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._get_nested_schema': ('funccall.html#_get_nested_schema', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._handle_container': ('funccall.html#_handle_container', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._handle_type': ('funccall.html#_handle_type', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._is_container': ('funccall.html#_is_container', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._is_parameterized': ('funccall.html#_is_parameterized', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._param': ('funccall.html#_param', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._process_property': ('funccall.html#_process_property', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._run': ('funccall.html#_run', 'toolslm/funccall.py'),
+                                  'toolslm.funccall._types': ('funccall.html#_types', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.call_func': ('funccall.html#call_func', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.call_func_async': ('funccall.html#call_func_async', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.get_schema': ('funccall.html#get_schema', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.mk_ns': ('funccall.html#mk_ns', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.mk_param': ('funccall.html#mk_param', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.mk_tool': ('funccall.html#mk_tool', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.python': ('funccall.html#python', 'toolslm/funccall.py'),
+                                  'toolslm.funccall.schema2sig': ('funccall.html#schema2sig', 'toolslm/funccall.py')},
+            'toolslm.md_hier': {},
+            'toolslm.shell': { 'toolslm.shell.TerminalInteractiveShell.run_cell': ( 'shell.html#terminalinteractiveshell.run_cell',
+                                                                                    'toolslm/shell.py'),
+                               'toolslm.shell.get_shell': ('shell.html#get_shell', 'toolslm/shell.py')},
+            'toolslm.xml': { 'toolslm.xml._add_nls': ('xml.html#_add_nls', 'toolslm/xml.py'),
+                             'toolslm.xml.cell2out': ('xml.html#cell2out', 'toolslm/xml.py'),
+                             'toolslm.xml.cell2xml': ('xml.html#cell2xml', 'toolslm/xml.py'),
+                             'toolslm.xml.docs_xml': ('xml.html#docs_xml', 'toolslm/xml.py'),
+                             'toolslm.xml.files2ctx': ('xml.html#files2ctx', 'toolslm/xml.py'),
+                             'toolslm.xml.folder2ctx': ('xml.html#folder2ctx', 'toolslm/xml.py'),
+                             'toolslm.xml.folder2ctx_cli': ('xml.html#folder2ctx_cli', 'toolslm/xml.py'),
+                             'toolslm.xml.get_mime_text': ('xml.html#get_mime_text', 'toolslm/xml.py'),
+                             'toolslm.xml.json_to_xml': ('xml.html#json_to_xml', 'toolslm/xml.py'),
+                             'toolslm.xml.mk_doc': ('xml.html#mk_doc', 'toolslm/xml.py'),
+                             'toolslm.xml.mk_doctype': ('xml.html#mk_doctype', 'toolslm/xml.py'),
+                             'toolslm.xml.nb2xml': ('xml.html#nb2xml', 'toolslm/xml.py'),
+                             'toolslm.xml.parse_gh_url': ('xml.html#parse_gh_url', 'toolslm/xml.py'),
+                             'toolslm.xml.read_file': ('xml.html#read_file', 'toolslm/xml.py'),
+                             'toolslm.xml.repo2ctx': ('xml.html#repo2ctx', 'toolslm/xml.py')}}}

toolslm-0.3.13/toolslm/download.py

@@ -0,0 +1,109 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../03_download.ipynb.
+
+# %% auto 0
+__all__ = ['clean_md', 'read_md', 'html2md', 'read_html', 'get_llmstxt', 'split_url', 'find_docs', 'read_docs']
+
+# %% ../03_download.ipynb
+from fastcore.utils import *
+from httpx import get
+from fastcore.meta import delegates
+from urllib.parse import urlparse, urljoin
+from .xml import parse_gh_url
+
+# %% ../03_download.ipynb
+def clean_md(text, rm_comments=True, rm_details=True):
+    "Remove comments and `<details>` sections from `text`"
+    if rm_comments: text = re.sub(r'\n?<!--.*?-->\n?', '', text, flags=re.DOTALL)
+    if rm_details: text = re.sub(r'\n?<details>.*?</details>\n?', '', text, flags=re.DOTALL)
+    return text
+
+# %% ../03_download.ipynb
+@delegates(get)
+def read_md(url, rm_comments=True, rm_details=True, **kwargs):
+    "Read text from `url` and clean with `clean_docs`"
+    return clean_md(get(url, **kwargs).text, rm_comments=rm_comments, rm_details=rm_details)
+
+# %% ../03_download.ipynb
+def html2md(s:str, ignore_links=True):
+    "Convert `s` from HTML to markdown"
+    import html2text
+    o = html2text.HTML2Text(bodywidth=5000)
+    o.ignore_links = ignore_links
+    o.mark_code = True
+    o.ignore_images = True
+    return o.handle(s)
+
+# %% ../03_download.ipynb
+def read_html(url, # URL to read
+              sel=None, # Read only outerHTML of CSS selector `sel`
+              rm_comments=True, # Removes HTML comments
+              rm_details=True, # Removes `<details>` tags
+              multi=False, # Get all matches to `sel` or first one  
+              wrap_tag=None, #If multi, each selection wrapped with <wrap_tag>content</wrap_tag>
+              ignore_links=True,
+             ): # Cleaned markdown
+    "Get `url`, optionally selecting CSS selector `sel`, and convert to clean markdown"
+    page = get(url).text
+    if sel:
+        from bs4 import BeautifulSoup
+        soup = BeautifulSoup(page, 'html.parser')
+        if multi:
+            page = [str(el) for el in soup.select(sel)]
+            if not wrap_tag: page = "\n".join(page)
+        else: page = str(soup.select_one(sel))
+    mds = map(lambda x: clean_md(html2md(x, ignore_links=ignore_links), rm_comments, rm_details=rm_details), tuplify(page))
+    if wrap_tag: return '\n'.join([f"\n<{wrap_tag}>\n{o}</{wrap_tag}>\n" for o in mds])
+    else: return'\n'.join(mds)
+
+# %% ../03_download.ipynb
+def get_llmstxt(url, optional=False, n_workers=None):
+    "Get llms.txt file from and expand it with `llms_txt.create_ctx()`"
+    if not url.endswith('llms.txt'): return None
+    import llms_txt
+    resp = get(url)
+    if resp.status_code!=200: return None
+    return llms_txt.create_ctx(resp.text, optional=optional, n_workers=n_workers)
+
+# %% ../03_download.ipynb
+def split_url(url):
+    "Split `url` into base, path, and file name, normalising name to '/' if empty"
+    parsed = urlparse(url.strip('/'))
+    base = f"{parsed.scheme}://{parsed.netloc}"
+    path,spl,fname = parsed.path.rpartition('/')
+    fname = spl+fname
+    if not path and not fname: path='/'
+    return base,path,fname
+
+# %% ../03_download.ipynb
+def _tryget(url):
+    "Return response from `url` if `status_code!=404`, otherwise `None`"
+    res = get(url)
+    return None if res.status_code==404 else url
+
+# %% ../03_download.ipynb
+def find_docs(url):
+    "If available, return LLM-friendly llms.txt context or markdown file location from `url`"
+    base,path,fname = split_url(url)
+    url = (base+path+fname).strip('/')
+    if fname=='/llms.txt': return url
+    if Path(fname).suffix in('.md', '.txt', '.rst'): return _tryget(url)
+    if '.' in fname: return _tryget(url+'.md') or find_docs(url[:url.rfind('/')])
+    res = _tryget(url+'/llms.txt')
+    if res: return res
+    res = _tryget(url+'/index.md')
+    if res: return res
+    res = _tryget(url+'/index.html.md')
+    if res: return res
+    res = _tryget(url+'/index-commonmark.md')
+    if res: return res
+    parsed_url = urlparse(url)
+    if parsed_url.path == '/' or not parsed_url.path: return None
+    return find_docs(urljoin(url, '..'))
+
+# %% ../03_download.ipynb
+def read_docs(url, optional=False, n_workers=None, rm_comments=True, rm_details=True):
+    "If available, return LLM-friendly llms.txt context or markdown file response for `url`"
+    url = find_docs(url)
+    if url.endswith('/llms.txt'): res = get_llmstxt(url, optional=optional, n_workers=n_workers)
+    else: res = get(url).text
+    return clean_md(res, rm_comments=rm_comments, rm_details=rm_details)

toolslm-0.3.13/toolslm/funccall.py

@@ -0,0 +1,274 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../01_funccall.ipynb.
+
+# %% auto 0
+__all__ = ['empty', 'custom_types', 'get_schema', 'python', 'mk_ns', 'call_func', 'call_func_async', 'mk_param', 'schema2sig',
+           'mk_tool']
+
+# %% ../01_funccall.ipynb
+import inspect, json, ast
+from collections import abc
+from fastcore.utils import *
+from fastcore.docments import docments
+from typing import get_origin, get_args, Dict, List, Optional, Tuple, Union, Any
+from types import UnionType
+from typing import get_type_hints
+from inspect import Parameter, Signature
+from decimal import Decimal
+from uuid import UUID
+
+# %% ../01_funccall.ipynb
+empty = inspect.Parameter.empty
+
+# %% ../01_funccall.ipynb
+def _types(t:type)->tuple[str,Optional[str]]:
+    "Tuple of json schema type name and (if appropriate) array item name."
+    if t is empty: raise TypeError('Missing type')
+    tmap = {int:"integer", float:"number", str:"string", bool:"boolean", list:"array", dict:"object"}
+    tmap.update({k.__name__: v for k, v in tmap.items()})
+    if getattr(t, '__origin__', None) in (list,tuple):
+        args = getattr(t, '__args__', None)
+        item_type = "object" if not args else tmap.get(t.__args__[0].__name__, "object")
+        return "array", item_type
+    # if t is a string like 'int', directly use the string as the key
+    elif isinstance(t, str): return tmap.get(t, "object"), None
+    # if t is the type itself and a container
+    elif get_origin(t): return tmap.get(get_origin(t).__name__, "object"), None
+    # if t is the type itself like int, use the __name__ representation as the key
+    else: return tmap.get(t.__name__, "object"), None
+
+# %% ../01_funccall.ipynb
+def _param(
+    name, # param name
+    info, # dict from docments
+    evalable=False): # stringify defaults that can't be literal_eval'd?
+    "json schema parameter given `name` and `info` from docments full dict"
+    paramt,itemt = _types(info.anno)
+    pschema = dict(type=paramt, description=info.docment or "")
+    if itemt: pschema["items"] = {"type": itemt}
+    if info.default is not empty:
+        if evalable:
+            try: ast.literal_eval(repr(info.default))
+            except: pschema["default"] = str(info.default)
+            else: pschema["default"] = info.default
+        else: pschema["default"] = info.default
+    return pschema
+
+# %% ../01_funccall.ipynb
+custom_types = {Path, bytes, Decimal, UUID}
+
+def _handle_type(t, defs):
+    "Handle a single type, creating nested schemas if necessary"
+    if t is NoneType: return {'type': 'null'}
+    if t in custom_types: return {'type':'string', 'format':t.__name__}
+    if t in (dict, list, tuple, set): return {'type': _types(t)[0]}
+    if isinstance(t, type) and not issubclass(t, (int, float, str, bool)) or inspect.isfunction(t):
+        defs[t.__name__] = _get_nested_schema(t)
+        return {'$ref': f'#/$defs/{t.__name__}'}
+    return {'type': _types(t)[0]}
+
+# %% ../01_funccall.ipynb
+def _is_container(t):
+    "Check if type is a container (list, dict, tuple, set, Union)"
+    origin = get_origin(t)
+    return origin in (list, dict, tuple, set, Union) if origin else False
+
+def _is_parameterized(t):
+    "Check if type has arguments (e.g. list[int] vs list, dict[str, int] vs dict)"
+    return _is_container(t) and (get_args(t) != ())
+
+# %% ../01_funccall.ipynb
+def _handle_container(origin, args, defs):
+    "Handle container types like dict, list, tuple, set, and Union"
+    if origin is Union or origin is UnionType:
+        return {"anyOf": [_handle_type(arg, defs) for arg in args]}
+    if origin is dict:
+        value_type = args[1].__args__[0] if hasattr(args[1], '__args__') else args[1]
+        return {
+            'type': 'object',
+            'additionalProperties': (
+                {'type': 'array', 'items': _handle_type(value_type, defs)}
+                if hasattr(args[1], '__origin__') else _handle_type(args[1], defs)
+            )
+        }
+    elif origin in (list, tuple, set):
+        schema = {'type': 'array', 'items': _handle_type(args[0], defs)}
+        if origin is set:
+            schema['uniqueItems'] = True
+        return schema
+    return None
+
+# %% ../01_funccall.ipynb
+def _process_property(name, obj, props, req, defs, evalable=False):
+    "Process a single property of the schema"
+    p = _param(name, obj, evalable=evalable)
+    props[name] = p
+    if obj.default is empty: req[name] = True
+
+    if _is_container(obj.anno) and _is_parameterized(obj.anno):
+        p.update(_handle_container(get_origin(obj.anno), get_args(obj.anno), defs))        
+    else:
+        # Non-container type or container without arguments
+        p.update(_handle_type(obj.anno, defs))
+
+# %% ../01_funccall.ipynb
+def _get_nested_schema(obj, evalable=False, skip_hidden=False):
+    "Generate nested JSON schema for a class or function"
+    d = docments(obj, full=True)
+    props, req, defs = {}, {}, {}
+
+    for n, o in d.items():
+        if n != 'return' and n != 'self' and not (skip_hidden and n.startswith('_')):
+            _process_property(n, o, props, req, defs, evalable=evalable)
+
+    tkw = {}
+    if isinstance(obj, type): tkw['title']=obj.__name__
+    schema = dict(type='object', properties=props, **tkw)
+    if req: schema['required'] = list(req)
+    if defs: schema['$defs'] = defs
+    return schema
+
+# %% ../01_funccall.ipynb
+def get_schema(
+    f:Union[callable,dict], # Function to get schema for
+    pname='input_schema',   # Key name for parameters
+    evalable=False,  # stringify defaults that can't be literal_eval'd?
+    skip_hidden=False # skip parameters starting with '_'?
+)->dict: # {'name':..., 'description':..., pname:...}
+    "Generate JSON schema for a class, function, or method"
+    if isinstance(f, dict): return f
+    schema = _get_nested_schema(f, evalable=evalable, skip_hidden=skip_hidden)
+    desc = f.__doc__
+    assert desc, "Docstring missing!"
+    d = docments(f, full=True)
+    ret = d.pop('return')
+    if (ret.anno is not empty) and (ret.anno is not None): desc += f'\n\nReturns:\n- type: {_types(ret.anno)[0]}'
+    return {"name": f.__name__, "description": desc, pname: schema}
+
+# %% ../01_funccall.ipynb
+import ast, time, signal, traceback
+from fastcore.utils import *
+
+# %% ../01_funccall.ipynb
+def _copy_loc(new, orig):
+    "Copy location information from original node to new node and all children."
+    new = ast.copy_location(new, orig)
+    for field, o in ast.iter_fields(new):
+        if isinstance(o, ast.AST): setattr(new, field, _copy_loc(o, orig))
+        elif isinstance(o, list): setattr(new, field, [_copy_loc(value, orig) for value in o])
+    return new
+
+# %% ../01_funccall.ipynb
+def _run(code:str, glb:dict=None, loc:dict=None):
+    "Run `code`, returning final expression (similar to IPython)"
+    tree = ast.parse(code)
+    last_node = tree.body[-1] if tree.body else None
+    
+    # If the last node is an expression, modify the AST to capture the result
+    if isinstance(last_node, ast.Expr):
+        tgt = [ast.Name(id='_result', ctx=ast.Store())]
+        assign_node = ast.Assign(targets=tgt, value=last_node.value)
+        tree.body[-1] = _copy_loc(assign_node, last_node)
+
+    compiled_code = compile(tree, filename='<ast>', mode='exec')
+    glb = glb or {}
+    stdout_buffer = io.StringIO()
+    saved_stdout = sys.stdout
+    sys.stdout = stdout_buffer
+    try: exec(compiled_code, glb, loc)
+    finally: sys.stdout = saved_stdout
+    _result = glb.get('_result', None)
+    if _result is not None: return _result
+    return stdout_buffer.getvalue().strip()
+
+# %% ../01_funccall.ipynb
+def python(
+    code:str, # Code to execute
+    glb:Optional[dict]=None, # Globals namespace
+    loc:Optional[dict]=None, # Locals namespace
+    timeout:int=3600 # Maximum run time in seconds
+):
+    "Executes python `code` with `timeout` and returning final expression (similar to IPython)."
+    def handler(*args): raise TimeoutError()
+    if glb is None: glb = inspect.currentframe().f_back.f_globals
+    if loc is None: loc=glb
+    signal.signal(signal.SIGALRM, handler)
+    signal.alarm(timeout)
+    try: return _run(code, glb, loc)
+    except Exception as e: return traceback.format_exc()
+    finally: signal.alarm(0)
+
+# %% ../01_funccall.ipynb
+def mk_ns(fs):
+    if isinstance(fs, abc.Mapping): return fs
+    merged = {}
+    for o in listify(fs):
+        if isinstance(o, dict): merged |= o
+        elif callable(o) and hasattr(o, '__name__'): merged |= {o.__name__: o}
+    return merged
+
+# %% ../01_funccall.ipynb
+def _coerce_inputs(func, inputs):
+    "Coerce inputs based on function type annotations"
+    hints = get_type_hints(func) if hasattr(func, '__annotations__') else {}
+    res = {}
+    for k,v in inputs.items():
+        ann = hints.get(k)
+        if ann in custom_types: res[k] = ann(v)
+        elif isinstance(v, dict) and callable(ann): res[k] = ann(**v)
+        else: res[k] = v
+    return res
+
+# %% ../01_funccall.ipynb
+def call_func(fc_name, fc_inputs, ns, raise_on_err=True):
+    "Call the function `fc_name` with the given `fc_inputs` using namespace `ns`."
+    if not isinstance(ns, abc.Mapping): ns = mk_ns(ns)
+    func = ns[fc_name]
+    inps = {re.sub(r'\W', '', k):v for k,v in fc_inputs.items()}
+    inps = _coerce_inputs(func, inps)
+    try: return func(**inps)
+    except Exception as e:
+        if raise_on_err: raise e from None
+        else: return traceback.format_exc()
+
+# %% ../01_funccall.ipynb
+async def call_func_async(fc_name, fc_inputs, ns, raise_on_err=True):
+    "Awaits the function `fc_name` with the given `fc_inputs` using namespace `ns`."
+    res = call_func(fc_name, fc_inputs, ns, raise_on_err=raise_on_err)
+    if inspect.iscoroutine(res):
+        try: res = await res
+        except Exception as e:
+            if raise_on_err: raise e from None
+            else: return traceback.format_exc()
+    return res
+
+# %% ../01_funccall.ipynb
+def mk_param(nm, props, req):
+    "Create a `Parameter` for `nm` with schema `props`"
+    kind = Parameter.POSITIONAL_OR_KEYWORD if nm in req else Parameter.KEYWORD_ONLY
+    default = Parameter.empty if nm in req else props.get('default')    
+    if props.get('type') == 'array' and 'items' in props:
+        item_type = type_map.get(props['items'].get('type'), Any)
+        anno = list[item_type]
+    else: anno = type_map.get(props.get('type'), Any)
+    return Parameter(nm, kind, default=default, annotation=anno)
+
+# %% ../01_funccall.ipynb
+def schema2sig(tool):
+    "Convert json schema `tool` to a `Signature`"
+    props, req = tool.inputSchema['properties'], tool.inputSchema.get('required', [])
+    params = sorted([mk_param(k, v, req) for k, v in props.items()], key=lambda p: p.kind)
+    return Signature(params)
+
+# %% ../01_funccall.ipynb
+def mk_tool(dispfn, tool):
+    "Create a callable function from a JSON schema tool definition"
+    sig = schema2sig(tool)
+    props = tool.inputSchema['properties']
+    def fn(*args, **kwargs):
+        bound = sig.bind(*args, **kwargs)
+        return dispfn(tool.name, **bound.arguments)
+    fn.__doc__ = tool.description
+    fn.__signature__ = sig
+    fn.__name__ = fn.__qualname__ = tool.name
+    fn.__annotations__ = {k: p.annotation for k, p in sig.parameters.items()}
+    return fn