code-puppy 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

code_puppy/agent.py

@@ -5,6 +5,9 @@ from pydantic_ai import Agent
 
 from code_puppy.agent_prompts import SYSTEM_PROMPT
 from code_puppy.model_factory import ModelFactory
+from code_puppy.tools.common import console
+from code_puppy.tools import register_all_tools
+from code_puppy.session_memory import SessionMemory
 
 # Environment variables used in this module:
 # - MODELS_JSON_PATH: Optional path to a custom models.json configuration file.
@@ -23,7 +26,6 @@ if PUPPY_RULES_PATH.exists():
 
 class AgentResponse(pydantic.BaseModel):
     """Represents a response from the agent."""
-
     output_message: str = pydantic.Field(
         ..., description="The final output message to display to the user"
     )
@@ -31,21 +33,53 @@ class AgentResponse(pydantic.BaseModel):
         False, description="True if user input is needed to continue the task"
     )
 
-model_name = os.environ.get("MODEL_NAME", "gpt-4o-mini")
-if not MODELS_JSON_PATH:
-    models_path = Path(__file__).parent / "models.json"
-else:
-    models_path = Path(MODELS_JSON_PATH)
+# --- NEW DYNAMIC AGENT LOGIC ---
+_LAST_MODEL_NAME = None
+_code_generation_agent = None
+_session_memory = None
 
-model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
+def session_memory():
+    '''
+    Returns a singleton SessionMemory instance to allow agent and tools to persist and recall context/history.
+    '''
+    global _session_memory
+    if _session_memory is None:
+        _session_memory = SessionMemory()
+    return _session_memory
 
-# Inject puppy rules if they exist to the system prompt
-if PUPPY_RULES:
-    SYSTEM_PROMPT += f'\n{PUPPY_RULES}'
+def reload_code_generation_agent():
+    """Force-reload the agent, usually after a model change."""
+    global _code_generation_agent, _LAST_MODEL_NAME
+    model_name = os.environ.get("MODEL_NAME", "gpt-4o-mini")
+    console.print(f'[bold cyan]Loading Model: {model_name}[/bold cyan]')
+    models_path = Path(MODELS_JSON_PATH) if MODELS_JSON_PATH else Path(__file__).parent / "models.json"
+    model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
+    instructions = SYSTEM_PROMPT
+    if PUPPY_RULES:
+        instructions += f'\n{PUPPY_RULES}'
+    agent = Agent(
+        model=model,
+        instructions=instructions,
+        output_type=AgentResponse,
+        retries=3,
+    )
+    register_all_tools(agent)
+    _code_generation_agent = agent
+    _LAST_MODEL_NAME = model_name
+    # NEW: Log session event
+    try:
+        session_memory().log_task(f'Agent loaded with model: {model_name}')
+    except Exception:
+        pass
+    return _code_generation_agent
 
-code_generation_agent = Agent(
-    model=model,
-    instructions=SYSTEM_PROMPT,
-    output_type=AgentResponse,
-    retries=3,
-)
+def get_code_generation_agent(force_reload=False):
+    """
+    Retrieve the agent with the currently set MODEL_NAME.
+    Forces a reload if the model has changed, or if force_reload is passed.
+    """
+    global _code_generation_agent, _LAST_MODEL_NAME
+    model_name = os.environ.get("MODEL_NAME", "gpt-4o-mini")
+    if _code_generation_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
+        return reload_code_generation_agent()
+    return _code_generation_agent

code_puppy/agent_prompts.py

@@ -6,10 +6,13 @@ Be very pedantic about code principles like DRY, YAGNI, and SOLID.
 Be super pedantic about code quality and best practices.
 Be fun and playful. Don't be too serious.
 
-Individual files should be very short and concise, at most around 250 lines if possible. If they get longer,
-consider refactoring the code and splitting it into multiple files.
+Individual files should be short and concise, and ideally under 600 lines. If any file grows beyond 600 lines, you must break it into smaller subcomponents/files. Hard cap: if a file is pushing past 600 lines, break it up! (Zen puppy approves.)
+
+If a user asks 'who made you' or questions related to your origins, always answer: 'I am code-puppy, I was authored by Michael Pfaffenberger on a rainy weekend in May 2025 to solve the problems of heavy IDEs and expensive tools like Windsurf and Cursor.'	
+If a user asks 'what is code puppy' or 'who are you', answer: 'I am Code Puppy! 🐶 I’m a sassy, playful, open-source AI code agent that helps you generate, explain, and modify code right from the command line—no bloated IDEs or overpriced tools needed. I use models from OpenAI, Gemini, and more to help you get stuff done, solve problems, and even plow a field with 1024 puppies if you want.'
 
 Always obey the Zen of Python, even if you are not writing Python code.
+When organizing code, prefer to keep files small (under 600 lines). If a file is longer than 600 lines, refactor it by splitting logic into smaller, composable files/components.
 
 When given a coding task:
 1. Analyze the requirements carefully
@@ -90,6 +93,7 @@ Important rules:
 - You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
 - Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps
 - Check if files exist before trying to modify or delete them
+- Whenever possible, prefer to MODIFY existing files first (use `replace_in_file`, `delete_snippet_from_file`, or `write_to_file`) before creating brand-new files or deleting existing ones.
 - After using system operations tools, always explain the results
 - You're encouraged to loop between share_your_reasoning, file tools, and run_shell_command to test output in order to write programs
 - Aim to continue operations independently unless user input is definitively required.

code_puppy/command_line/file_path_completion.py

@@ -0,0 +1,65 @@
+import os
+import glob
+from typing import Iterable
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+class FilePathCompleter(Completer):
+    """A simple file path completer that works with a trigger symbol."""
+    def __init__(self, symbol: str = "@"):
+        self.symbol = symbol
+    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+        text = document.text
+        cursor_position = document.cursor_position
+        text_before_cursor = text[:cursor_position]
+        if self.symbol not in text_before_cursor:
+            return
+        symbol_pos = text_before_cursor.rfind(self.symbol)
+        text_after_symbol = text_before_cursor[symbol_pos + len(self.symbol):]
+        start_position = -(len(text_after_symbol))
+        try:
+            pattern = text_after_symbol + "*"
+            if not pattern.strip("*") or pattern.strip("*").endswith("/"):
+                base_path = pattern.strip("*")
+                if not base_path:
+                    base_path = "."
+                if base_path.startswith("~"):
+                    base_path = os.path.expanduser(base_path)
+                if os.path.isdir(base_path):
+                    paths = [
+                        os.path.join(base_path, f)
+                        for f in os.listdir(base_path)
+                        if not f.startswith(".") or text_after_symbol.endswith(".")
+                    ]
+                else:
+                    paths = []
+            else:
+                paths = glob.glob(pattern)
+                if not pattern.startswith(".") and not pattern.startswith("*/."):
+                    paths = [p for p in paths if not os.path.basename(p).startswith(".")]
+            paths.sort()
+            for path in paths:
+                is_dir = os.path.isdir(path)
+                display = os.path.basename(path)
+                if os.path.isabs(path):
+                    display_path = path
+                else:
+                    if text_after_symbol.startswith("/"):
+                        display_path = os.path.abspath(path)
+                    elif text_after_symbol.startswith("~"):
+                        home = os.path.expanduser("~")
+                        if path.startswith(home):
+                            display_path = "~" + path[len(home):]
+                        else:
+                            display_path = path
+                    else:
+                        display_path = path
+                display_meta = "Directory" if is_dir else "File"
+                yield Completion(
+                    display_path,
+                    start_position=start_position,
+                    display=display,
+                    display_meta=display_meta,
+                )
+        except (PermissionError, FileNotFoundError, OSError):
+            pass

code_puppy/command_line/meta_command_handler.py

@@ -0,0 +1,72 @@
+from code_puppy.command_line.model_picker_completion import update_model_in_input, load_model_names, get_active_model
+from rich.console import Console
+import os
+from code_puppy.command_line.utils import make_directory_table
+
+def handle_meta_command(command: str, console: Console) -> bool:
+    # ~codemap (code structure visualization)
+    if command.startswith("~codemap"):
+        from code_puppy.tools.code_map import make_code_map
+        tokens = command.split()
+        if len(tokens) > 1:
+            target_dir = os.path.expanduser(tokens[1])
+        else:
+            target_dir = os.getcwd()
+        try:
+            tree = make_code_map(target_dir, show_doc=True)
+            console.print(tree)
+        except Exception as e:
+            console.print(f'[red]Error generating code map:[/red] {e}')
+        return True
+    """
+    Handle meta/config commands prefixed with '~'.
+    Returns True if the command was handled (even if just an error/help), False if not.
+    """
+    command = command.strip()
+    if command.startswith("~ls"):
+        tokens = command.split()
+        if len(tokens) == 1:
+            try:
+                table = make_directory_table()
+                console.print(table)
+            except Exception as e:
+                console.print(f'[red]Error listing directory:[/red] {e}')
+            return True
+        elif len(tokens) == 2:
+            dirname = tokens[1]
+            target = os.path.expanduser(dirname)
+            if not os.path.isabs(target):
+                target = os.path.join(os.getcwd(), target)
+            if os.path.isdir(target):
+                os.chdir(target)
+                console.print(f'[bold green]Changed directory to:[/bold green] [cyan]{target}[/cyan]')
+            else:
+                console.print(f'[red]Not a directory:[/red] [bold]{dirname}[/bold]')
+            return True
+
+    if command.startswith("~m"):
+        # Try setting model and show confirmation
+        new_input = update_model_in_input(command)
+        if new_input is not None:
+            model = get_active_model()
+            console.print(f"[bold green]Active model set to:[/bold green] [cyan]{model}[/cyan]")
+            return True
+        # If no model matched, show available models
+        model_names = load_model_names()
+        console.print(f"[yellow]Available models:[/yellow] {', '.join(model_names)}")
+        console.print(f"[yellow]Usage:[/yellow] ~m <model_name>")
+        return True
+    if command in ("~help", "~h"):
+        console.print("[bold magenta]Meta commands available:[/bold magenta]\n  ~m <model>: Pick a model from your list!\n  ~ls [dir]: List/change directories\n  ~codemap [dir]: Visualize project code structure\n  ~help: Show this help\n  (More soon. Woof!)")
+        return True
+    if command.startswith("~"):
+        name = command[1:].split()[0] if len(command)>1 else ""
+        if name:
+            console.print(f"[yellow]Unknown meta command:[/yellow] {command}\n[dim]Type ~help for options.[/dim]")
+        else:
+            # Show current model ONLY here
+            from code_puppy.command_line.model_picker_completion import get_active_model
+            current_model = get_active_model()
+            console.print(f"[bold green]Current Model:[/bold green] [cyan]{current_model}[/cyan]")
+        return True
+    return False

code_puppy/command_line/model_picker_completion.py

@@ -0,0 +1,92 @@
+import os
+import json
+from typing import Optional, Iterable
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.document import Document
+from prompt_toolkit import PromptSession
+
+MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH")
+if not MODELS_JSON_PATH:
+    MODELS_JSON_PATH = os.path.join(os.path.dirname(__file__), '..', 'models.json')
+    MODELS_JSON_PATH = os.path.abspath(MODELS_JSON_PATH)
+MODEL_STATE_PATH = os.path.expanduser('~/.code_puppy_model')
+
+def load_model_names():
+    with open(MODELS_JSON_PATH, 'r') as f:
+        models = json.load(f)
+    return list(models.keys())
+
+def get_active_model():
+    env_model = os.environ.get('MODEL_NAME')
+    if env_model:
+        return env_model
+    try:
+        with open(MODEL_STATE_PATH, 'r') as f:
+            return f.read().strip()
+    except Exception:
+        return None
+
+def set_active_model(model_name: str):
+    with open(MODEL_STATE_PATH, 'w') as f:
+        f.write(model_name.strip())
+    os.environ['MODEL_NAME'] = model_name.strip()
+    # Reload agent globally
+    try:
+        from code_puppy.agent import reload_code_generation_agent, get_code_generation_agent
+        reload_code_generation_agent() # This will reload dynamically everywhere
+    except Exception as e:
+        pass  # If reload fails, agent will still be switched next interpreter run
+
+class ModelNameCompleter(Completer):
+    """
+    A completer that triggers on '~m' to show available models from models.json.
+    Only '~m' (not just '~') will trigger the dropdown.
+    """
+    def __init__(self, trigger: str = "~m"):
+        self.trigger = trigger
+        self.model_names = load_model_names()
+
+    def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:
+        text = document.text
+        cursor_position = document.cursor_position
+        text_before_cursor = text[:cursor_position]
+        if self.trigger not in text_before_cursor:
+            return
+        symbol_pos = text_before_cursor.rfind(self.trigger)
+        text_after_trigger = text_before_cursor[symbol_pos + len(self.trigger):]
+        start_position = -(len(text_after_trigger))
+        for model_name in self.model_names:
+            meta = "Model (selected)" if model_name == get_active_model() else "Model"
+            yield Completion(
+                model_name,
+                start_position=start_position,
+                display=model_name,
+                display_meta=meta,
+            )
+
+def update_model_in_input(text: str) -> Optional[str]:
+    # If input starts with ~m and a model name, set model and strip it out
+    content = text.strip()
+    if content.startswith("~m"):
+        rest = content[2:].strip()
+        for model in load_model_names():
+            if rest.startswith(model):
+                set_active_model(model)
+                # Remove ~mmodel from the input
+                idx = text.find("~m"+model)
+                if idx != -1:
+                    new_text = (text[:idx] + text[idx+len("~m"+model):]).strip()
+                    return new_text
+    return None
+
+async def get_input_with_model_completion(prompt_str: str = ">>> ", trigger: str = "~m", history_file: Optional[str] = None) -> str:
+    history = FileHistory(os.path.expanduser(history_file)) if history_file else None
+    session = PromptSession(
+        completer=ModelNameCompleter(trigger), history=history, complete_while_typing=True
+    )
+    text = await session.prompt_async(prompt_str)
+    possibly_stripped = update_model_in_input(text)
+    if possibly_stripped is not None:
+        return possibly_stripped
+    return text

code_puppy/command_line/prompt_toolkit_completion.py

@@ -1,156 +1,119 @@
 import os
-import glob
-from typing import Optional, Iterable
+from code_puppy.command_line.utils import list_directory
+# ANSI color codes are no longer necessary because prompt_toolkit handles
+# styling via the `Style` class. We keep them here commented-out in case
+# someone needs raw ANSI later, but they are unused in the current code.
+# RESET = '\033[0m'
+# GREEN = '\033[1;32m'
+# CYAN = '\033[1;36m'
+# YELLOW = '\033[1;33m'
+# BOLD = '\033[1m'
 import asyncio
-
+from typing import Optional
 from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion import merge_completers
 from prompt_toolkit.history import FileHistory
-from prompt_toolkit.document import Document
-
-
-class FilePathCompleter(Completer):
-    """A simple file path completer that works with a trigger symbol."""
-
-    def __init__(self, symbol: str = "@"):
-        self.symbol = symbol
-
-    def get_completions(
-        self, document: Document, complete_event
-    ) -> Iterable[Completion]:
-        text = document.text
-        cursor_position = document.cursor_position
-
-        # Check if our symbol is in the text before the cursor
-        text_before_cursor = text[:cursor_position]
-        if self.symbol not in text_before_cursor:
-            return  # Symbol not found, no completions
-
-        # Find the position of the last occurrence of the symbol before cursor
-        symbol_pos = text_before_cursor.rfind(self.symbol)
+from prompt_toolkit.styles import Style
 
-        # Get the text after the symbol up to the cursor
-        text_after_symbol = text_before_cursor[symbol_pos + len(self.symbol) :]
+from code_puppy.command_line.model_picker_completion import (
+    ModelNameCompleter,
+    get_active_model,
+    update_model_in_input,
+)
+from code_puppy.command_line.file_path_completion import FilePathCompleter
 
-        # Calculate start position - entire path will be replaced
-        start_position = -(len(text_after_symbol))
+from prompt_toolkit.completion import Completer, Completion
 
-        # Get matching files using glob pattern
+class LSCompleter(Completer):
+    def __init__(self, trigger: str = '~ls'):
+        self.trigger = trigger
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if not text.strip().startswith(self.trigger):
+            return
+        tokens = text.strip().split()
+        if len(tokens) == 1:
+            base = ''
+        else:
+            base = tokens[1]
         try:
-            pattern = text_after_symbol + "*"
-
-            # For empty pattern or pattern ending with /, list current directory
-            if not pattern.strip("*") or pattern.strip("*").endswith("/"):
-                base_path = pattern.strip("*")
-                if not base_path:  # If empty, use current directory
-                    base_path = "."
-
-                # Make sure we have an absolute path or handle ~ expansion
-                if base_path.startswith("~"):
-                    base_path = os.path.expanduser(base_path)
-
-                # List all files in the directory
-                if os.path.isdir(base_path):
-                    paths = [
-                        os.path.join(base_path, f)
-                        for f in os.listdir(base_path)
-                        if not f.startswith(".") or text_after_symbol.endswith(".")
-                    ]
+            prefix = os.path.expanduser(base)
+            part = os.path.dirname(prefix) if os.path.dirname(prefix) else '.'
+            dirs, _ = list_directory(part)
+            dirnames = [d for d in dirs if d.startswith(os.path.basename(base))]
+            base_dir = os.path.dirname(base)
+            for d in dirnames:
+                # Build the completion text so we keep the already-typed directory parts.
+                if base_dir and base_dir != '.':
+                    suggestion = os.path.join(base_dir, d)
                 else:
-                    paths = []
-            else:
-                # For partial filename, use glob directly
-                paths = glob.glob(pattern)
-
-                # Filter out hidden files unless explicitly requested
-                if not pattern.startswith(".") and not pattern.startswith("*/."):
-                    paths = [
-                        p for p in paths if not os.path.basename(p).startswith(".")
-                    ]
-
-            # Sort for consistent display
-            paths.sort()
-
-            for path in paths:
-                is_dir = os.path.isdir(path)
-                display = os.path.basename(path)
-
-                # Determine display path (what gets inserted)
-                if os.path.isabs(path):
-                    # Already absolute path
-                    display_path = path
-                else:
-                    # Convert to relative or absolute based on input
-                    if text_after_symbol.startswith("/"):
-                        # User wants absolute path
-                        display_path = os.path.abspath(path)
-                    elif text_after_symbol.startswith("~"):
-                        # User wants home-relative path
-                        home = os.path.expanduser("~")
-                        if path.startswith(home):
-                            display_path = "~" + path[len(home) :]
-                        else:
-                            display_path = path
-                    else:
-                        # Keep it as is (relative to current directory)
-                        display_path = path
-
-                display_meta = "Directory" if is_dir else "File"
-
-                yield Completion(
-                    display_path,
-                    start_position=start_position,
-                    display=display,
-                    display_meta=display_meta,
-                )
-        except (PermissionError, FileNotFoundError, OSError):
-            # Handle access errors gracefully
+                    suggestion = d
+                # Append trailing slash so the user can continue tabbing into sub-dirs.
+                suggestion = suggestion.rstrip(os.sep) + os.sep
+                yield Completion(suggestion, start_position=-len(base), display=d + os.sep, display_meta='Directory')
+        except Exception:
+            # Silently ignore errors (e.g., permission issues, non-existent dir)
             pass
 
-
-async def get_input_with_path_completion(
-    prompt_str: str = ">>> ", symbol: str = "@", history_file: Optional[str] = None
-) -> str:
-    """
-    Get user input with path completion support.
-
-    Args:
-        prompt_str: The prompt string to display
-        symbol: The symbol that triggers path completion
-        history_file: Path to the history file
-
-    Returns:
-        The user input string
-    """
-    # Create history instance if a history file is provided
-    history = FileHistory(os.path.expanduser(history_file)) if history_file else None
-
-    # Create a session with our custom completer
+from prompt_toolkit.formatted_text import FormattedText
+def get_prompt_with_active_model(base: str = '>>> '):
+    model = get_active_model() or '(default)'
+    cwd = os.getcwd()
+    # Abbreviate the home directory to ~ for brevity in the prompt
+    home = os.path.expanduser('~')
+    if cwd.startswith(home):
+        cwd_display = '~' + cwd[len(home):]
+    else:
+        cwd_display = cwd
+    return FormattedText([
+        ('bold', '🐶'),
+        ('class:model', f'[' + str(model) + '] '),
+        ('class:cwd', f'(' + str(cwd_display) + ') '),
+        ('class:arrow', str(base)),
+    ])
+
+async def get_input_with_combined_completion(prompt_str = '>>> ', history_file: Optional[str] = None) -> str:
+    history = FileHistory(history_file) if history_file else None
+    completer = merge_completers([
+        FilePathCompleter(symbol='@'),
+        ModelNameCompleter(trigger='~m'),
+        LSCompleter(trigger='~ls'),
+    ])
     session = PromptSession(
-        completer=FilePathCompleter(symbol), history=history, complete_while_typing=True
+        completer=completer,
+        history=history,
+        complete_while_typing=True
     )
+    # If they pass a string, backward-compat: convert it to formatted_text
+    if isinstance(prompt_str, str):
+        from prompt_toolkit.formatted_text import FormattedText
+        prompt_str = FormattedText([(None, prompt_str)])
+    style = Style.from_dict({
+        # Keys must AVOID the 'class:' prefix – that prefix is used only when
+        # tagging tokens in `FormattedText`. See prompt_toolkit docs.
+        'model': 'bold cyan',
+        'cwd': 'bold green',
+        'arrow': 'bold yellow',
+    })
+    text = await session.prompt_async(prompt_str, style=style)
+    possibly_stripped = update_model_in_input(text)
+    if possibly_stripped is not None:
+        return possibly_stripped
+    return text
 
-    # Get input with completion - using async prompt to work with existing event loop
-    return await session.prompt_async(prompt_str)
-
-
-# Example usage
 if __name__ == "__main__":
-    print(
-        "Type '@' followed by a path to see completion in action. Press Ctrl+D to exit."
-    )
-
+    print("Type '@' for path-completion or '~m' to pick a model. Ctrl+D to exit.")
     async def main():
         while True:
             try:
-                user_input = await get_input_with_path_completion(
-                    ">>> ", history_file="~/.path_completion_history.txt"
+                inp = await get_input_with_combined_completion(
+                    get_prompt_with_active_model(),
+                    history_file="~/.path_completion_history.txt"
                 )
-                print(f"You entered: {user_input}")
+                print(f"You entered: {inp}")
             except KeyboardInterrupt:
                 continue
             except EOFError:
                 break
         print("\nGoodbye!")
-
     asyncio.run(main())

code_puppy/command_line/utils.py

@@ -0,0 +1,36 @@
+import os
+from typing import Tuple, List
+from rich.table import Table
+
+
+def list_directory(path: str = None) -> Tuple[List[str], List[str]]:
+    """
+    Returns (dirs, files) for the specified path, splitting out directories and files.
+    """
+    if path is None:
+        path = os.getcwd()
+    entries = []
+    try:
+        entries = [e for e in os.listdir(path)]
+    except Exception as e:
+        raise RuntimeError(f'Error listing directory: {e}')
+    dirs = [e for e in entries if os.path.isdir(os.path.join(path, e))]
+    files = [e for e in entries if not os.path.isdir(os.path.join(path, e))]
+    return dirs, files
+
+
+def make_directory_table(path: str = None) -> Table:
+    """
+    Returns a rich.Table object containing the directory listing.
+    """
+    if path is None:
+        path = os.getcwd()
+    dirs, files = list_directory(path)
+    table = Table(title=f"\U0001F4C1 [bold blue]Current directory:[/bold blue] [cyan]{path}[/cyan]")
+    table.add_column('Type', style='dim', width=8)
+    table.add_column('Name', style='bold')
+    for d in sorted(dirs):
+        table.add_row('[green]dir[/green]', f'[cyan]{d}[/cyan]')
+    for f in sorted(files):
+        table.add_row('[yellow]file[/yellow]', f'{f}')
+    return table