Utilities

from swarms import initialize_logger

logger = initialize_logger(log_folder="my_logs")

logger.info("Application started")
logger.error("An error occurred")
logger.debug("Debug information")

from swarms.utils.formatter import Formatter

formatter = Formatter(md=True)

# Print formatted panels
formatter.print_panel(
    "Analysis complete",
    title="Status",
    style="bold green"
)

# Print markdown with syntax highlighting
formatter.print_markdown(
    "# Results\n\n```python\nprint('hello')\n```",
    title="Code Output"
)

formatter.print_panel(
    content="Task completed successfully",
    title="Success",
    style="bold green"
)

formatter.print_markdown(
    content="# Analysis\n\nResults are **positive**",
    title="Report",
    border_style="blue"
)

response = formatter.print_streaming_panel(
    streaming_response=llm_stream,
    title="Agent Response",
    collect_chunks=True
)

agents_data = [
    {"name": "Agent-1", "status": "running", "output": "Processing..."},
    {"name": "Agent-2", "status": "completed", "output": "Done!"}
]

formatter.print_agent_dashboard(
    agents_data=agents_data,
    title="Swarm Dashboard",
    is_final=False
)

from swarms import format_dict_to_string

text = format_dict_to_string({"name": "Agent", "config": {"loops": 3}})
print(text)

from swarms import format_data_structure

text = format_data_structure({"agents": ["A", "B"], "count": 2})
print(text)

from swarms import exists

exists(None)  # False
exists("value")  # True

from swarms import create_file_in_folder

file_path = create_file_in_folder(
    folder_path="./reports",
    file_name="analysis.txt",
    content="Financial analysis results..."
)

from swarms import sanitize_file_path

safe_path = sanitize_file_path("`C:/Users/file<name>.txt`")
# Returns: C__Users_file_name_.txt

from swarms import load_json

json_str = '{"name": "Agent", "status": "active"}'
data = load_json(json_str)
print(data["name"])  # "Agent"

from swarms import zip_workspace

zip_path = zip_workspace(
    workspace_path="./my_workspace",
    output_filename="workspace_backup"
)

from swarms import zip_folders

zip_folders(
    folder1_path="./data",
    folder2_path="./logs",
    zip_file_path="combined_backup"
)

from swarms import count_tokens

text = "Analyze the financial statements"
token_count = count_tokens(
    text=text,
    model="gpt-5.4"
)
print(f"Tokens: {token_count}")

from swarms.utils.litellm_tokenizer import get_supported_models

models = get_supported_models()
print(models)

from swarms import load_agent_from_markdown

agent = load_agent_from_markdown("agent_config.md")

from swarms import load_agents_from_markdown

agents = load_agents_from_markdown([
    "agent1.md",
    "agent2.md",
    "agent3.md"
])

from swarms import MarkdownAgentLoader

loader = MarkdownAgentLoader(max_workers=4)

agent = loader.load_single_agent("agent_config.md")
agents = loader.load_multiple_agents("./agent_configs")

from swarms.structs.conversation import Conversation

conversation = Conversation(
    context_length=4000,
    tokenizer_model_name="gpt-5.4",
)

conversation.add("user", "...very long document...")
conversation.add("assistant", "...long analysis...")

trimmed = conversation.dynamic_auto_chunking()
print(f"Trimmed length: {len(trimmed)} chars")

from swarms import history_output_formatter

formatted = history_output_formatter(
    conversation=conversation_history,
    type="str",
)
print(formatted)

from swarms import LiteLLM

llm = LiteLLM(
    model_name="gpt-5.4",
    temperature=0.7,
    max_tokens=1000
)

response = llm.run("Analyze this data")
print(llm.usage)

from swarms import NetworkConnectionError

try:
    response = llm.run(prompt)
except NetworkConnectionError as e:
    print(f"Network error: {e}")
    # Handle retry logic

from swarms import LiteLLMException

try:
    response = llm.run(prompt)
except LiteLLMException as e:
    print(f"LiteLLM error: {e}")

from swarms import WorkspaceManager

manager = WorkspaceManager(owner=my_swarm, verbose=True)
print(manager.dir)
manager.save_conversation(my_swarm.conversation)

from swarms import (
    initialize_logger,
    create_file_in_folder,
    count_tokens,
    sanitize_file_path,
)
from swarms.utils.formatter import Formatter

# Initialize logging
logger = initialize_logger("my_app")
logger.info("Starting application")

# Create formatter for output
formatter = Formatter(md=True)

# Process some data
markdown_content = """
# Analysis Results

The quarter closed **above** forecast.
"""

# Count tokens
tokens = count_tokens(markdown_content, model="gpt-5.4")
formatter.print_panel(
    f"Report has {tokens} tokens",
    title="Token Count",
    style="bold cyan"
)

# Save to file
safe_path = sanitize_file_path("./reports/analysis_results.txt")
file_path = create_file_in_folder(
    folder_path="./reports",
    file_name="analysis_results.txt",
    content=markdown_content
)

logger.info(f"Saved to: {file_path}")

# Display markdown
formatter.print_markdown(
    markdown_content,
    title="Analysis Report",
    border_style="green"
)