llm-function 0.0.1__py3-none-any.whl

llm_function/artifacts/.paa.tracking/git/module/llm_function.py

@@ -0,0 +1,250 @@
+"""
+`llm_function` helps you build reusable LLM functions with normal Python signatures.
+
+You define a function with Pydantic input and output models, describe what it should do
+in the docstring, and provide a set of available tools. At runtime, `llm_function`
+uses [`workflow_auto_assembler`](https://pypi.org/project/workflow-auto-assembler/) to
+assemble and execute a workflow that satisfies that typed function contract.
+
+The result is an LLM-backed function that can be reused like any other Python function,
+while still being grounded in explicit tools, schemas, and config.
+
+Tool definition and discovery live in
+[`llm_function_tools`](https://pypi.org/project/llm-function-tools/).
+"""
+
+import asyncio
+import attrs
+import attrsx
+import inspect
+import threading
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional, Type, get_type_hints
+
+from pydantic import BaseModel
+from workflow_auto_assembler import WorkflowAutoAssembler
+from .components.llm_func_deps.llm_function_config import LlmFunctionConfig, LlmRuntimeConfig
+from .components.llm_func_deps.tool_registry import InMemoryToolSource, ToolRegistry
+
+__package_metadata__ = {
+    "author": "Kyrylo Mordan",
+    "author_email": "parachute.repo@gmail.com",
+    "description": "Llm function is a decorator that uses llm to assemble reusable workflows from available tools to match input and output models.",
+    "url" : 'https://kiril-mordan.github.io/adaptive-reusables/llm-function/',
+}
+
+
+@attrsx.define
+class LlmFunction:
+    available_functions: Optional[List[Any]] = attrs.field(default=None)
+    available_callables: Optional[Dict[str, Callable[..., Any]]] = attrs.field(default=None)
+    tool_registry: Optional[ToolRegistry] = attrs.field(default=None)
+    tool_sources: Optional[List[object]] = attrs.field(default=None)
+    config: Optional[LlmFunctionConfig] = attrs.field(default=None)
+    llm_handler_params: Optional[dict] = attrs.field(default=None)
+    storage_path: Optional[str] = attrs.field(default=None)
+    force_replan: bool = attrs.field(default=False)
+    max_retry: Optional[int] = attrs.field(default=None)
+    reset_loops: Optional[int] = attrs.field(default=None)
+    compare_params: Optional[dict] = attrs.field(default=None)
+    test_params: Optional[list] = attrs.field(default=None)
+    resolved_tools: Optional[Dict[str, Any]] = attrs.field(default=None, init=False)
+
+    def __attrs_post_init__(self):
+        self._apply_config_defaults()
+
+        if self.llm_handler_params is None:
+            raise ValueError("llm_handler_params is required either directly or via config.")
+
+        self.resolved_tools = self._resolve_available_tools()
+
+    def _apply_config_defaults(self):
+        if self.config is None:
+            return
+
+        if self.llm_handler_params is None:
+            self.llm_handler_params = self.config.runtime.llm_handler_params
+        if self.storage_path is None:
+            self.storage_path = self.config.runtime.storage_path
+        if self.force_replan is False:
+            self.force_replan = self.config.runtime.force_replan
+        if self.max_retry is None:
+            self.max_retry = self.config.runtime.max_retry
+        if self.reset_loops is None:
+            self.reset_loops = self.config.runtime.reset_loops
+        if self.compare_params is None:
+            self.compare_params = self.config.runtime.compare_params
+        if self.test_params is None:
+            self.test_params = self.config.runtime.test_params
+        if self.tool_registry is None:
+            self.tool_registry = self.config.tool_registry
+        if self.tool_sources is None and self.config.tool_sources is not None:
+            self.tool_sources = list(self.config.tool_sources)
+
+    def _normalize_task_description(self, func: Callable[..., Any]) -> str:
+        task_description = inspect.cleandoc(func.__doc__ or "").strip()
+        if not task_description:
+            raise ValueError("Decorated function must define a docstring to use as task_description.")
+
+        return task_description
+
+    def _extract_io_models(self, func: Callable[..., Any]) -> tuple[Type[BaseModel], Type[BaseModel], str]:
+        signature = inspect.signature(func)
+        params = list(signature.parameters.values())
+        if len(params) != 1:
+            raise ValueError("Decorated function must accept exactly one parameter annotated with a BaseModel subclass.")
+
+        input_param = params[0]
+        hints = get_type_hints(func)
+        input_model = hints.get(input_param.name)
+        output_model = hints.get("return")
+
+        if not inspect.isclass(input_model) or not issubclass(input_model, BaseModel):
+            raise TypeError("Decorated function input annotation must be a Pydantic BaseModel subclass.")
+
+        if not inspect.isclass(output_model) or not issubclass(output_model, BaseModel):
+            raise TypeError("Decorated function return annotation must be a Pydantic BaseModel subclass.")
+
+        return input_model, output_model, input_param.name
+
+    def _coerce_run_inputs(self, input_model: Type[BaseModel], run_inputs: Any) -> BaseModel:
+        if isinstance(run_inputs, input_model):
+            return run_inputs
+
+        if hasattr(input_model, "model_validate"):
+            return input_model.model_validate(run_inputs)
+
+        return input_model.parse_obj(run_inputs)
+
+    def _run_coro_blocking(self, coro):
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(coro)
+
+        result: Dict[str, Any] = {}
+        error: Dict[str, BaseException] = {}
+
+        def _thread_main():
+            try:
+                result["value"] = asyncio.run(coro)
+            except BaseException as exc:  # pragma: no cover
+                error["value"] = exc
+
+        thread = threading.Thread(target=_thread_main, daemon=True)
+        thread.start()
+        thread.join()
+
+        if "value" in error:
+            raise error["value"]
+
+        return result["value"]
+
+    def _resolve_available_tools(self) -> Dict[str, Any]:
+        if self.tool_registry is not None and self.tool_sources is not None:
+            raise ValueError("Use either tool_registry or tool_sources, not both.")
+
+        if self.tool_registry is not None:
+            return self.tool_registry.build_available_tools()
+
+        if self.tool_sources is not None:
+            return ToolRegistry(sources=self.tool_sources).build_available_tools()
+
+        if self.available_functions is None or self.available_callables is None:
+            raise ValueError(
+                "Provide either available_functions and available_callables, or tool_registry/tool_sources."
+            )
+
+        return {
+            "available_functions": self.available_functions,
+            "available_callables": self.available_callables,
+            "resolved_tools": None,
+        }
+
+    def as_decorator(self):
+        def decorator(func: Callable[..., Any]):
+            signature = inspect.signature(func)
+            task_description = self._normalize_task_description(func)
+            input_model, output_model, input_name = self._extract_io_models(func)
+
+            async def _invoke_async(run_inputs: Any):
+                wa = WorkflowAutoAssembler(
+                    available_functions=self.resolved_tools["available_functions"],
+                    available_callables=self.resolved_tools["available_callables"],
+                    storage_path=self.storage_path,
+                    llm_handler_params=self.llm_handler_params,
+                )
+
+                return await wa.actualize_workflow(
+                    task_description=task_description,
+                    force_replan=self.force_replan,
+                    run_inputs=self._coerce_run_inputs(input_model=input_model, run_inputs=run_inputs),
+                    test_params=self.test_params,
+                    compare_params=self.compare_params,
+                    input_model=input_model,
+                    output_model=output_model,
+                    max_retry=self.max_retry,
+                    reset_loops=self.reset_loops,
+                )
+
+            if inspect.iscoroutinefunction(func):
+
+                @wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    bound = signature.bind(*args, **kwargs)
+                    return await _invoke_async(bound.arguments[input_name])
+
+                async_wrapper.input_model = input_model
+                async_wrapper.output_model = output_model
+                async_wrapper.task_description = task_description
+                async_wrapper.ainvoke = _invoke_async
+                async_wrapper.resolved_tools = self.resolved_tools["resolved_tools"]
+                return async_wrapper
+
+            @wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                bound = signature.bind(*args, **kwargs)
+                return self._run_coro_blocking(_invoke_async(bound.arguments[input_name]))
+
+            sync_wrapper.input_model = input_model
+            sync_wrapper.output_model = output_model
+            sync_wrapper.task_description = task_description
+            sync_wrapper.ainvoke = _invoke_async
+            sync_wrapper.resolved_tools = self.resolved_tools["resolved_tools"]
+            return sync_wrapper
+
+        return decorator
+
+
+def llm_function(
+    *,
+    available_functions: Optional[List[Any]] = None,
+    available_callables: Optional[Dict[str, Callable[..., Any]]] = None,
+    tool_registry: Optional[ToolRegistry] = None,
+    tool_sources: Optional[List[object]] = None,
+    config: Optional[LlmFunctionConfig] = None,
+    llm_handler_params: Optional[dict] = None,
+    storage_path: Optional[str] = None,
+    force_replan: bool = False,
+    max_retry: Optional[int] = None,
+    reset_loops: Optional[int] = None,
+    compare_params: Optional[dict] = None,
+    test_params: Optional[list] = None,
+):
+    """
+    Decorate a typed function and route its calls through WorkflowAutoAssembler.
+    """
+    return LlmFunction(
+        available_functions=available_functions,
+        available_callables=available_callables,
+        tool_registry=tool_registry,
+        tool_sources=tool_sources,
+        config=config,
+        llm_handler_params=llm_handler_params,
+        storage_path=storage_path,
+        force_replan=force_replan,
+        max_retry=max_retry,
+        reset_loops=reset_loops,
+        compare_params=compare_params,
+        test_params=test_params,
+    ).as_decorator()

llm_function/artifacts/.paa.tracking/git/tracking/release_notes.md

@@ -0,0 +1,5 @@
+# Release notes
+
+### 0.0.1
+
+    - initial version of llm-function

llm_function/artifacts/.paa.tracking/git_repo/COMMIT_EDITMSG

@@ -0,0 +1 @@
+checkpoint[make-package] version=0.0.1 ts=2026-03-29T15:54:16.335632+00:00

llm_function/artifacts/.paa.tracking/git_repo/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

llm_function/artifacts/.paa.tracking/git_repo/config

@@ -0,0 +1,8 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[user]
+	name = PAA Checkpoint
+	email = paa@local

llm_function/artifacts/.paa.tracking/git_repo/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.

llm_function/artifacts/.paa.tracking/git_repo/hooks/applypatch-msg.sample

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
+test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
+:

llm_function/artifacts/.paa.tracking/git_repo/hooks/commit-msg.sample

@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

llm_function/artifacts/.paa.tracking/git_repo/hooks/fsmonitor-watchman.sample

@@ -0,0 +1,174 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use IPC::Open2;
+
+# An example hook script to integrate Watchman
+# (https://facebook.github.io/watchman/) with git to speed up detecting
+# new and modified files.
+#
+# The hook is passed a version (currently 2) and last update token
+# formatted as a string and outputs to stdout a new update token and
+# all files that have been modified since the update token. Paths must
+# be relative to the root of the working tree and separated by a single NUL.
+#
+# To enable this hook, rename this file to "query-watchman" and set
+# 'git config core.fsmonitor .git/hooks/query-watchman'
+#
+my ($version, $last_update_token) = @ARGV;
+
+# Uncomment for debugging
+# print STDERR "$0 $version $last_update_token\n";
+
+# Check the hook interface version
+if ($version ne 2) {
+	die "Unsupported query-fsmonitor hook version '$version'.\n" .
+	    "Falling back to scanning...\n";
+}
+
+my $git_work_tree = get_working_dir();
+
+my $retry = 1;
+
+my $json_pkg;
+eval {
+	require JSON::XS;
+	$json_pkg = "JSON::XS";
+	1;
+} or do {
+	require JSON::PP;
+	$json_pkg = "JSON::PP";
+};
+
+launch_watchman();
+
+sub launch_watchman {
+	my $o = watchman_query();
+	if (is_work_tree_watched($o)) {
+		output_result($o->{clock}, @{$o->{files}});
+	}
+}
+
+sub output_result {
+	my ($clockid, @files) = @_;
+
+	# Uncomment for debugging watchman output
+	# open (my $fh, ">", ".git/watchman-output.out");
+	# binmode $fh, ":utf8";
+	# print $fh "$clockid\n@files\n";
+	# close $fh;
+
+	binmode STDOUT, ":utf8";
+	print $clockid;
+	print "\0";
+	local $, = "\0";
+	print @files;
+}
+
+sub watchman_clock {
+	my $response = qx/watchman clock "$git_work_tree"/;
+	die "Failed to get clock id on '$git_work_tree'.\n" .
+		"Falling back to scanning...\n" if $? != 0;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub watchman_query {
+	my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty')
+	or die "open2() failed: $!\n" .
+	"Falling back to scanning...\n";
+
+	# In the query expression below we're asking for names of files that
+	# changed since $last_update_token but not from the .git folder.
+	#
+	# To accomplish this, we're using the "since" generator to use the
+	# recency index to select candidate nodes and "fields" to limit the
+	# output to file names only. Then we're using the "expression" term to
+	# further constrain the results.
+	my $last_update_line = "";
+	if (substr($last_update_token, 0, 1) eq "c") {
+		$last_update_token = "\"$last_update_token\"";
+		$last_update_line = qq[\n"since": $last_update_token,];
+	}
+	my $query = <<"	END";
+		["query", "$git_work_tree", {$last_update_line
+			"fields": ["name"],
+			"expression": ["not", ["dirname", ".git"]]
+		}]
+	END
+
+	# Uncomment for debugging the watchman query
+	# open (my $fh, ">", ".git/watchman-query.json");
+	# print $fh $query;
+	# close $fh;
+
+	print CHLD_IN $query;
+	close CHLD_IN;
+	my $response = do {local $/; <CHLD_OUT>};
+
+	# Uncomment for debugging the watch response
+	# open ($fh, ">", ".git/watchman-response.json");
+	# print $fh $response;
+	# close $fh;
+
+	die "Watchman: command returned no output.\n" .
+	"Falling back to scanning...\n" if $response eq "";
+	die "Watchman: command returned invalid output: $response\n" .
+	"Falling back to scanning...\n" unless $response =~ /^\{/;
+
+	return $json_pkg->new->utf8->decode($response);
+}
+
+sub is_work_tree_watched {
+	my ($output) = @_;
+	my $error = $output->{error};
+	if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) {
+		$retry--;
+		my $response = qx/watchman watch "$git_work_tree"/;
+		die "Failed to make watchman watch '$git_work_tree'.\n" .
+		    "Falling back to scanning...\n" if $? != 0;
+		$output = $json_pkg->new->utf8->decode($response);
+		$error = $output->{error};
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		# Uncomment for debugging watchman output
+		# open (my $fh, ">", ".git/watchman-output.out");
+		# close $fh;
+
+		# Watchman will always return all files on the first query so
+		# return the fast "everything is dirty" flag to git and do the
+		# Watchman query just to get it over with now so we won't pay
+		# the cost in git to look up each individual file.
+		my $o = watchman_clock();
+		$error = $output->{error};
+
+		die "Watchman: $error.\n" .
+		"Falling back to scanning...\n" if $error;
+
+		output_result($o->{clock}, ("/"));
+		$last_update_token = $o->{clock};
+
+		eval { launch_watchman() };
+		return 0;
+	}
+
+	die "Watchman: $error.\n" .
+	"Falling back to scanning...\n" if $error;
+
+	return 1;
+}
+
+sub get_working_dir {
+	my $working_dir;
+	if ($^O =~ 'msys' || $^O =~ 'cygwin') {
+		$working_dir = Win32::GetCwd();
+		$working_dir =~ tr/\\/\//;
+	} else {
+		require Cwd;
+		$working_dir = Cwd::cwd();
+	}
+
+	return $working_dir;
+}

llm_function/artifacts/.paa.tracking/git_repo/hooks/post-update.sample

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

llm_function/artifacts/.paa.tracking/git_repo/hooks/pre-applypatch.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+precommit="$(git rev-parse --git-path hooks/pre-commit)"
+test -x "$precommit" && exec "$precommit" ${1+"$@"}
+:

llm_function/artifacts/.paa.tracking/git_repo/hooks/pre-commit.sample

@@ -0,0 +1,49 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --type=bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff-index --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

llm_function/artifacts/.paa.tracking/git_repo/hooks/pre-merge-commit.sample

@@ -0,0 +1,13 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git merge" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message to
+# stderr if it wants to stop the merge commit.
+#
+# To enable this hook, rename this file to "pre-merge-commit".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+        exec "$GIT_DIR/hooks/pre-commit"
+:

llm_function/artifacts/.paa.tracking/git_repo/hooks/pre-push.sample

@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local oid> <remote ref> <remote oid>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+
+while read local_ref local_oid remote_ref remote_oid
+do
+	if test "$local_oid" = "$zero"
+	then
+		# Handle delete
+		:
+	else
+		if test "$remote_oid" = "$zero"
+		then
+			# New branch, examine all commits
+			range="$local_oid"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_oid..$local_oid"
+		fi
+
+		# Check for WIP commit
+		commit=$(git rev-list -n 1 --grep '^WIP' "$range")
+		if test -n "$commit"
+		then
+			echo >&2 "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0