llm-function 0.0.1__py3-none-any.whl

llm_function/.paa.tracking/git_repo/hooks/sendemail-validate.sample

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+# An example hook script to validate a patch (and/or patch series) before
+# sending it via email.
+#
+# The hook should exit with non-zero status after issuing an appropriate
+# message if it wants to prevent the email(s) from being sent.
+#
+# To enable this hook, rename this file to "sendemail-validate".
+#
+# By default, it will only check that the patch(es) can be applied on top of
+# the default upstream branch without conflicts in a secondary worktree. After
+# validation (successful or not) of the last patch of a series, the worktree
+# will be deleted.
+#
+# The following config variables can be set to change the default remote and
+# remote ref that are used to apply the patches against:
+#
+#   sendemail.validateRemote (default: origin)
+#   sendemail.validateRemoteRef (default: HEAD)
+#
+# Replace the TODO placeholders with appropriate checks according to your
+# needs.
+
+validate_cover_letter () {
+	file="$1"
+	# TODO: Replace with appropriate checks (e.g. spell checking).
+	true
+}
+
+validate_patch () {
+	file="$1"
+	# Ensure that the patch applies without conflicts.
+	git am -3 "$file" || return
+	# TODO: Replace with appropriate checks for this patch
+	# (e.g. checkpatch.pl).
+	true
+}
+
+validate_series () {
+	# TODO: Replace with appropriate checks for the whole series
+	# (e.g. quick build, coding style checks, etc.).
+	true
+}
+
+# main -------------------------------------------------------------------------
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = 1
+then
+	remote=$(git config --default origin --get sendemail.validateRemote) &&
+	ref=$(git config --default HEAD --get sendemail.validateRemoteRef) &&
+	worktree=$(mktemp --tmpdir -d sendemail-validate.XXXXXXX) &&
+	git worktree add -fd --checkout "$worktree" "refs/remotes/$remote/$ref" &&
+	git config --replace-all sendemail.validateWorktree "$worktree"
+else
+	worktree=$(git config --get sendemail.validateWorktree)
+fi || {
+	echo "sendemail-validate: error: failed to prepare worktree" >&2
+	exit 1
+}
+
+unset GIT_DIR GIT_WORK_TREE
+cd "$worktree" &&
+
+if grep -q "^diff --git " "$1"
+then
+	validate_patch "$1"
+else
+	validate_cover_letter "$1"
+fi &&
+
+if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL"
+then
+	git config --unset-all sendemail.validateWorktree &&
+	trap 'git worktree remove -ff "$worktree"' EXIT &&
+	validate_series
+fi

llm_function/.paa.tracking/git_repo/hooks/update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to block unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --type=bool hooks.allowunannotated)
+allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --type=bool hooks.denycreatebranch)
+allowdeletetag=$(git config --type=bool hooks.allowdeletetag)
+allowmodifytag=$(git config --type=bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero=$(git hash-object --stdin </dev/null | tr '[0-9a-f]' '0')
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

llm_function/.paa.tracking/git_repo/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

llm_function/.paa.tracking/git_repo/logs/HEAD

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 139201e8ffeb4e42262e90eeaefd5267debb6e1d PAA Checkpoint <paa@local> 1774799656 +0000	commit (initial): checkpoint[make-package] version=0.0.1 ts=2026-03-29T15:54:16.335632+00:00

llm_function/.paa.tracking/git_repo/logs/refs/heads/master

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 139201e8ffeb4e42262e90eeaefd5267debb6e1d PAA Checkpoint <paa@local> 1774799656 +0000	commit (initial): checkpoint[make-package] version=0.0.1 ts=2026-03-29T15:54:16.335632+00:00

llm_function/.paa.tracking/git_repo/objects/13/9201e8ffeb4e42262e90eeaefd5267debb6e1d

@@ -0,0 +1 @@
+x
����@D����ȾD����3��"��X�~���SN2gN���&�n�LJ�:8����yXC�v%��1%4)o���_��3��G85�)�c�݄x�c�~�Ze�7�������+��,���
;�'>�o��6�+X�!-�`��L��_�.�*�)��F�U�\

llm_function/.paa.tracking/git_repo/refs/heads/master

@@ -0,0 +1 @@
+139201e8ffeb4e42262e90eeaefd5267debb6e1d

llm_function/.paa.tracking/git_repo/refs/tags/v0.0.1

@@ -0,0 +1 @@
+139201e8ffeb4e42262e90eeaefd5267debb6e1d

llm_function/.paa.tracking/lsts_package_versions.yml

@@ -0,0 +1,3 @@
+llm_function: 0.0.1
+llm_function_tools: 0.0.1
+workflow_auto_assembler: 0.1.0

llm_function/.paa.tracking/package_licenses.json

@@ -0,0 +1 @@
+{}

llm_function/.paa.tracking/package_mapping.json

@@ -0,0 +1 @@
+{}

llm_function/.paa.tracking/python_modules/components/llm_func_deps/llm_function_config.py

@@ -0,0 +1,35 @@
+"""
+Config models for llm_function runtime wiring.
+"""
+
+from typing import Any, Optional, Sequence
+
+from pydantic import BaseModel, Field
+
+
+class LlmRuntimeConfig(BaseModel):
+    """
+    Reusable runtime settings for llm_function execution.
+    """
+
+    llm_handler_params: dict = Field(description="Parameters passed to WorkflowAutoAssembler LLM handler.")
+    storage_path: Optional[str] = Field(default=None, description="Optional storage path for workflow persistence.")
+    force_replan: bool = Field(default=False, description="Force workflow replanning instead of reusing cached workflows.")
+    max_retry: Optional[int] = Field(default=None, description="Optional max retry override for planning loops.")
+    reset_loops: Optional[int] = Field(default=None, description="Optional reset loop override for planning loops.")
+    compare_params: Optional[dict] = Field(default=None, description="Optional compare parameters for workflow validation.")
+    test_params: Optional[list] = Field(default=None, description="Optional test cases for planning/validation.")
+
+
+class LlmFunctionConfig(BaseModel):
+    """
+    Bundled llm_function configuration for future config-driven decorator usage.
+    """
+
+    runtime: LlmRuntimeConfig = Field(description="Runtime settings for workflow execution.")
+    tool_sources: Optional[Sequence[Any]] = Field(default=None, description="Configured tool sources for runtime loading.")
+    tool_registry: Optional[Any] = Field(default=None, description="Optional prebuilt tool registry.")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }

llm_function/.paa.tracking/python_modules/components/llm_func_deps/tool_registry.py

@@ -0,0 +1,250 @@
+"""
+Runtime tool loading helpers for llm_function.
+"""
+
+import attrs
+import attrsx
+import inspect
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+
+from pydantic import BaseModel, Field, SkipValidation
+from workflow_auto_assembler import LlmFunctionItem, make_uid
+
+from llm_function_tools import (
+    ToolSpec,
+    load_tools_from_module,
+    load_tools_from_python_file,
+    tool_from_callable,
+)
+
+
+class ResolvedTool(BaseModel):
+    """
+    Runtime-ready tool definition with provenance metadata.
+    """
+
+    tool_spec: ToolSpec = Field(description="Normalized tool definition.")
+    func: SkipValidation[Callable[..., Any]] = Field(description="Runtime callable for the tool.")
+    source_type: str = Field(description="Source kind, for example file or module.")
+    location_type: str = Field(description="Location kind, for example local or external.")
+    package_name: Optional[str] = Field(default=None, description="Optional package name.")
+    package_version: Optional[str] = Field(default=None, description="Optional resolved package version.")
+    module_name: Optional[str] = Field(default=None, description="Python module that defined the tool.")
+    file_path: Optional[str] = Field(default=None, description="Local file path when the tool was loaded from a file.")
+    origin_ref: Optional[str] = Field(default=None, description="Original source reference used to load the tool.")
+    metadata: dict = Field(default_factory=dict, description="Additional runtime metadata.")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+    }
+
+
+@attrsx.define
+class InMemoryToolSource:
+    """
+    Resolve tools directly from callables, ToolSpec objects, or ResolvedTool objects.
+    """
+
+    tools: Sequence[Union[Callable[..., Any], ToolSpec, ResolvedTool]] = attrs.field()
+    location_type: str = attrs.field(default="local")
+    package_name: Optional[str] = attrs.field(default=None)
+    package_version: Optional[str] = attrs.field(default=None)
+    origin_ref: Optional[str] = attrs.field(default=None)
+
+    def __attrs_post_init__(self):
+        self.tools = list(self.tools)
+
+    def load_tools(self) -> List[ResolvedTool]:
+        """
+        Resolve in-memory tools into runtime tool records.
+        """
+
+        resolved_tools: List[ResolvedTool] = []
+        for item in self.tools:
+            if isinstance(item, ResolvedTool):
+                resolved_tools.append(item)
+                continue
+
+            tool_spec = item if isinstance(item, ToolSpec) else tool_from_callable(item)
+            resolved_tools.append(
+                ResolvedTool(
+                    tool_spec=tool_spec,
+                    func=tool_spec.func,
+                    source_type="memory",
+                    location_type=self.location_type,
+                    package_name=self.package_name,
+                    package_version=self.package_version,
+                    module_name=getattr(tool_spec.func, "__module__", None),
+                    origin_ref=self.origin_ref,
+                )
+            )
+
+        return resolved_tools
+
+
+@attrsx.define
+class PythonModuleToolSource:
+    """
+    Resolve tools from an importable Python module.
+    """
+
+    module_name: str = attrs.field()
+    include_plain_typed: bool = attrs.field(default=False)
+    location_type: str = attrs.field(default="local")
+    package_name: Optional[str] = attrs.field(default=None)
+    package_version: Optional[str] = attrs.field(default=None)
+
+    def load_tools(self) -> List[ResolvedTool]:
+        """
+        Import module and resolve tools declared inside it.
+        """
+
+        resolved_tools: List[ResolvedTool] = []
+        for tool_spec in load_tools_from_module(
+            self.module_name,
+            include_plain_typed=self.include_plain_typed,
+        ):
+            resolved_tools.append(
+                ResolvedTool(
+                    tool_spec=tool_spec,
+                    func=tool_spec.func,
+                    source_type="module",
+                    location_type=self.location_type,
+                    package_name=self.package_name,
+                    package_version=self.package_version,
+                    module_name=self.module_name,
+                    origin_ref=self.module_name,
+                )
+            )
+
+        return resolved_tools
+
+
+@attrsx.define
+class PythonFileToolSource:
+    """
+    Resolve tools from a standalone Python file path.
+    """
+
+    file_path: str = attrs.field()
+    include_plain_typed: bool = attrs.field(default=False)
+    location_type: str = attrs.field(default="local")
+    package_name: Optional[str] = attrs.field(default=None)
+    package_version: Optional[str] = attrs.field(default=None)
+    module_name: Optional[str] = attrs.field(default=None)
+
+    def load_tools(self) -> List[ResolvedTool]:
+        """
+        Import file and resolve tools declared inside it.
+        """
+
+        resolved_path = str(Path(self.file_path).expanduser().resolve())
+        resolved_tools: List[ResolvedTool] = []
+        for tool_spec in load_tools_from_python_file(
+            resolved_path,
+            include_plain_typed=self.include_plain_typed,
+            module_name=self.module_name,
+        ):
+            resolved_tools.append(
+                ResolvedTool(
+                    tool_spec=tool_spec,
+                    func=tool_spec.func,
+                    source_type="file",
+                    location_type=self.location_type,
+                    package_name=self.package_name,
+                    package_version=self.package_version,
+                    module_name=getattr(tool_spec.func, "__module__", self.module_name),
+                    file_path=resolved_path,
+                    origin_ref=resolved_path,
+                )
+            )
+
+        return resolved_tools
+
+
+@attrsx.define
+class ToolRegistry:
+    """
+    Aggregate tools from one or more sources and expose WAA-compatible tool lists.
+    """
+
+    sources: Sequence[object] = attrs.field()
+    _resolved_tools: Optional[List[ResolvedTool]] = attrs.field(default=None)
+
+    def __attrs_post_init__(self):
+        self.sources = list(self.sources)
+
+    def load_tools(self, reload: bool = False) -> List[ResolvedTool]:
+        """
+        Resolve all configured sources into runtime tools.
+        """
+
+        if self._resolved_tools is not None and not reload:
+            return list(self._resolved_tools)
+
+        resolved_tools: List[ResolvedTool] = []
+        seen_keys = set()
+
+        for source in self.sources:
+            for resolved_tool in source.load_tools():
+                dedupe_key = (
+                    resolved_tool.tool_spec.name,
+                    resolved_tool.module_name,
+                    resolved_tool.file_path,
+                    resolved_tool.package_name,
+                    resolved_tool.package_version,
+                )
+                if dedupe_key in seen_keys:
+                    continue
+                seen_keys.add(dedupe_key)
+                resolved_tools.append(resolved_tool)
+
+        self._resolved_tools = resolved_tools
+        return list(self._resolved_tools)
+
+    @staticmethod
+    def _safe_source_code(func: Callable[..., Any]) -> str:
+        """
+        Best-effort source capture for stable tool hashing.
+        """
+
+        try:
+            return inspect.getsource(func)
+        except (OSError, TypeError):
+            return getattr(func, "__qualname__", getattr(func, "__name__", ""))
+
+    def build_available_tools(self) -> Dict[str, Any]:
+        """
+        Convert resolved tools into WorkflowAutoAssembler-compatible structures.
+        """
+
+        available_functions: List[LlmFunctionItem] = []
+        available_callables: Dict[str, Callable[..., Any]] = {}
+
+        for resolved_tool in self.load_tools():
+            llm_func_item = {
+                "name": resolved_tool.tool_spec.name,
+                "description": resolved_tool.tool_spec.description,
+                "input_schema_json": resolved_tool.tool_spec.input_model.model_json_schema(),
+                "output_schema_json": resolved_tool.tool_spec.output_model.model_json_schema(),
+                "code": self._safe_source_code(resolved_tool.func),
+            }
+            func_id = make_uid(d=llm_func_item)
+
+            available_functions.append(
+                LlmFunctionItem(
+                    func_id=func_id,
+                    name=llm_func_item["name"],
+                    description=llm_func_item["description"],
+                    input_schema_json=llm_func_item["input_schema_json"],
+                    output_schema_json=llm_func_item["output_schema_json"],
+                )
+            )
+            available_callables[func_id] = resolved_tool.func
+
+        return {
+            "available_functions": available_functions,
+            "available_callables": available_callables,
+            "resolved_tools": self.load_tools(),
+        }