628 lines
23 KiB
Python
628 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Manage agent-installed and run-active skill directories for each run."""
|
|
|
|
from pathlib import Path
|
|
import shutil
|
|
from typing import Dict, Iterable, List
|
|
|
|
import yaml
|
|
|
|
from backend.agents.agent_workspace import load_agent_workspace_config
|
|
from backend.agents.skill_metadata import SkillMetadata, parse_skill_metadata
|
|
from backend.config.bootstrap_config import get_bootstrap_config_for_run
|
|
|
|
|
|
class SkillsManager:
|
|
"""Sync named skills into a run-scoped active skills workspace."""
|
|
|
|
def __init__(self, project_root: Path | None = None):
|
|
self.project_root = (
|
|
project_root or Path(__file__).resolve().parents[2]
|
|
)
|
|
self.builtin_root = self.project_root / "backend" / "skills" / "builtin"
|
|
self.customized_root = (
|
|
self.project_root / "backend" / "skills" / "customized"
|
|
)
|
|
self.runs_root = self.project_root / "runs"
|
|
|
|
def get_active_root(self, config_name: str) -> Path:
|
|
return self.runs_root / config_name / "skills" / "active"
|
|
|
|
def get_agent_skills_root(self, config_name: str, agent_id: str) -> Path:
|
|
return self.get_agent_asset_dir(config_name, agent_id) / "skills"
|
|
|
|
def get_agent_active_root(self, config_name: str, agent_id: str) -> Path:
|
|
return self.get_agent_skills_root(config_name, agent_id) / "active"
|
|
|
|
def get_agent_installed_root(self, config_name: str, agent_id: str) -> Path:
|
|
return self.get_agent_skills_root(config_name, agent_id) / "installed"
|
|
|
|
def get_agent_disabled_root(self, config_name: str, agent_id: str) -> Path:
|
|
return self.get_agent_skills_root(config_name, agent_id) / "disabled"
|
|
|
|
def get_agent_local_root(self, config_name: str, agent_id: str) -> Path:
|
|
return self.get_agent_skills_root(config_name, agent_id) / "local"
|
|
|
|
def get_activation_manifest_path(self, config_name: str) -> Path:
|
|
return self.runs_root / config_name / "skills" / "activation.yaml"
|
|
|
|
def get_agent_asset_dir(self, config_name: str, agent_id: str) -> Path:
|
|
return self.runs_root / config_name / "agents" / agent_id
|
|
|
|
def list_skill_catalog(self) -> List[SkillMetadata]:
|
|
"""Return builtin/customized skills with parsed metadata."""
|
|
catalog: Dict[str, SkillMetadata] = {}
|
|
|
|
for source, root in (
|
|
("builtin", self.builtin_root),
|
|
("customized", self.customized_root),
|
|
):
|
|
if not root.exists():
|
|
continue
|
|
for skill_dir in sorted(root.iterdir(), key=lambda item: item.name):
|
|
if not skill_dir.is_dir():
|
|
continue
|
|
if not (skill_dir / "SKILL.md").exists():
|
|
continue
|
|
metadata = parse_skill_metadata(skill_dir, source=source)
|
|
catalog[metadata.skill_name] = metadata
|
|
|
|
return sorted(catalog.values(), key=lambda item: item.skill_name)
|
|
|
|
def list_agent_skill_catalog(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
) -> List[SkillMetadata]:
|
|
"""Return shared plus agent-local skills for one agent."""
|
|
catalog = {
|
|
item.skill_name: item
|
|
for item in self.list_skill_catalog()
|
|
}
|
|
for item in self.list_agent_local_skills(config_name, agent_id):
|
|
catalog[item.skill_name] = item
|
|
return sorted(catalog.values(), key=lambda item: item.skill_name)
|
|
|
|
def list_active_skill_metadata(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
) -> List[SkillMetadata]:
|
|
"""Return metadata for active skills synced for one agent."""
|
|
active_root = self.get_agent_active_root(config_name, agent_id)
|
|
if not active_root.exists():
|
|
return []
|
|
|
|
items: List[SkillMetadata] = []
|
|
for skill_dir in sorted(active_root.iterdir(), key=lambda item: item.name):
|
|
if not skill_dir.is_dir():
|
|
continue
|
|
if not (skill_dir / "SKILL.md").exists():
|
|
continue
|
|
items.append(parse_skill_metadata(skill_dir, source="active"))
|
|
return items
|
|
|
|
def list_agent_local_skills(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
) -> List[SkillMetadata]:
|
|
"""Return metadata for agent-private local skills."""
|
|
local_root = self.get_agent_local_root(config_name, agent_id)
|
|
if not local_root.exists():
|
|
return []
|
|
|
|
items: List[SkillMetadata] = []
|
|
for skill_dir in sorted(local_root.iterdir(), key=lambda item: item.name):
|
|
if not skill_dir.is_dir():
|
|
continue
|
|
if not (skill_dir / "SKILL.md").exists():
|
|
continue
|
|
items.append(parse_skill_metadata(skill_dir, source="local"))
|
|
return items
|
|
|
|
def load_skill_document(self, skill_name: str) -> Dict[str, object]:
|
|
"""Return skill metadata plus markdown body for one skill."""
|
|
source_dir = self._resolve_source_dir(skill_name)
|
|
return self._load_skill_document_from_dir(
|
|
source_dir,
|
|
source="customized" if source_dir.parent == self.customized_root else "builtin",
|
|
)
|
|
|
|
def load_agent_skill_document(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
) -> Dict[str, object]:
|
|
"""Return skill metadata plus markdown body for one agent-visible skill."""
|
|
source_dir = self._resolve_agent_skill_source_dir(
|
|
config_name=config_name,
|
|
agent_id=agent_id,
|
|
skill_name=skill_name,
|
|
)
|
|
source = "local"
|
|
if source_dir.parent == self.customized_root:
|
|
source = "customized"
|
|
elif source_dir.parent == self.builtin_root:
|
|
source = "builtin"
|
|
elif source_dir.parent == self.get_agent_installed_root(config_name, agent_id):
|
|
source = "installed"
|
|
return self._load_skill_document_from_dir(source_dir, source=source)
|
|
|
|
def create_agent_local_skill(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
) -> Path:
|
|
"""Create a new local skill directory with a default SKILL.md."""
|
|
normalized = _normalize_skill_name(skill_name)
|
|
if not normalized:
|
|
raise ValueError("Skill name is required.")
|
|
local_root = self.get_agent_local_root(config_name, agent_id)
|
|
local_root.mkdir(parents=True, exist_ok=True)
|
|
skill_dir = local_root / normalized
|
|
if skill_dir.exists():
|
|
raise FileExistsError(f"Local skill already exists: {normalized}")
|
|
skill_dir.mkdir(parents=True, exist_ok=False)
|
|
(skill_dir / "SKILL.md").write_text(
|
|
"---\n"
|
|
f"name: {normalized}\n"
|
|
"description: 当用户提出与该本地技能相关的专门任务时，应使用此技能。\n"
|
|
"version: 1.0.0\n"
|
|
"---\n\n"
|
|
f"# {normalized}\n\n"
|
|
"在这里描述该交易员的专有分析流程、判断框架和可复用步骤。\n",
|
|
encoding="utf-8",
|
|
)
|
|
return skill_dir
|
|
|
|
def update_agent_local_skill(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
content: str,
|
|
) -> Path:
|
|
"""Overwrite one agent-local SKILL.md."""
|
|
normalized = _normalize_skill_name(skill_name)
|
|
if not normalized:
|
|
raise ValueError("Skill name is required.")
|
|
skill_dir = self.get_agent_local_root(config_name, agent_id) / normalized
|
|
if not skill_dir.exists():
|
|
raise FileNotFoundError(f"Unknown local skill: {normalized}")
|
|
(skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
|
|
return skill_dir
|
|
|
|
def delete_agent_local_skill(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
) -> None:
|
|
"""Delete one agent-local skill directory."""
|
|
normalized = _normalize_skill_name(skill_name)
|
|
if not normalized:
|
|
raise ValueError("Skill name is required.")
|
|
skill_dir = self.get_agent_local_root(config_name, agent_id) / normalized
|
|
if not skill_dir.exists():
|
|
raise FileNotFoundError(f"Unknown local skill: {normalized}")
|
|
shutil.rmtree(skill_dir)
|
|
|
|
def _load_skill_document_from_dir(
|
|
self,
|
|
source_dir: Path,
|
|
*,
|
|
source: str,
|
|
) -> Dict[str, object]:
|
|
"""Return metadata plus markdown body for one resolved skill directory."""
|
|
metadata = parse_skill_metadata(
|
|
source_dir,
|
|
source=source,
|
|
)
|
|
skill_file = source_dir / "SKILL.md"
|
|
raw = skill_file.read_text(encoding="utf-8").strip() if skill_file.exists() else ""
|
|
body = raw
|
|
if raw.startswith("---"):
|
|
parts = raw.split("---", 2)
|
|
if len(parts) >= 3:
|
|
body = parts[2].strip()
|
|
|
|
return {
|
|
"skill_name": metadata.skill_name,
|
|
"name": metadata.name,
|
|
"description": metadata.description,
|
|
"version": metadata.version,
|
|
"tools": metadata.tools,
|
|
"source": metadata.source,
|
|
"content": body,
|
|
}
|
|
|
|
def update_agent_skill_overrides(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
*,
|
|
enable: Iterable[str] | None = None,
|
|
disable: Iterable[str] | None = None,
|
|
) -> Dict[str, List[str]]:
|
|
"""Persist per-agent enabled/disabled skill overrides in agent.yaml."""
|
|
asset_dir = self.get_agent_asset_dir(config_name, agent_id)
|
|
asset_dir.mkdir(parents=True, exist_ok=True)
|
|
config_path = asset_dir / "agent.yaml"
|
|
current = load_agent_workspace_config(config_path)
|
|
values = dict(current.values)
|
|
|
|
enabled = _dedupe_preserve_order(current.enabled_skills)
|
|
disabled_set = set(current.disabled_skills)
|
|
|
|
for skill_name in enable or []:
|
|
if skill_name not in enabled:
|
|
enabled.append(skill_name)
|
|
disabled_set.discard(skill_name)
|
|
|
|
for skill_name in disable or []:
|
|
disabled_set.add(skill_name)
|
|
enabled = [item for item in enabled if item != skill_name]
|
|
|
|
values["enabled_skills"] = enabled
|
|
values["disabled_skills"] = sorted(disabled_set)
|
|
config_path.write_text(
|
|
yaml.safe_dump(values, allow_unicode=True, sort_keys=False),
|
|
encoding="utf-8",
|
|
)
|
|
return {
|
|
"enabled_skills": enabled,
|
|
"disabled_skills": sorted(disabled_set),
|
|
}
|
|
|
|
def forget_agent_skill_overrides(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_names: Iterable[str],
|
|
) -> Dict[str, List[str]]:
|
|
"""Remove skills from both enabled/disabled overrides in agent.yaml."""
|
|
asset_dir = self.get_agent_asset_dir(config_name, agent_id)
|
|
asset_dir.mkdir(parents=True, exist_ok=True)
|
|
config_path = asset_dir / "agent.yaml"
|
|
current = load_agent_workspace_config(config_path)
|
|
values = dict(current.values)
|
|
removed = set(skill_names)
|
|
|
|
enabled = [item for item in current.enabled_skills if item not in removed]
|
|
disabled = [item for item in current.disabled_skills if item not in removed]
|
|
|
|
values["enabled_skills"] = enabled
|
|
values["disabled_skills"] = disabled
|
|
config_path.write_text(
|
|
yaml.safe_dump(values, allow_unicode=True, sort_keys=False),
|
|
encoding="utf-8",
|
|
)
|
|
return {
|
|
"enabled_skills": enabled,
|
|
"disabled_skills": disabled,
|
|
}
|
|
|
|
def ensure_activation_manifest(self, config_name: str) -> Path:
|
|
manifest_path = self.get_activation_manifest_path(config_name)
|
|
manifest_path.parent.mkdir(parents=True, exist_ok=True)
|
|
if not manifest_path.exists():
|
|
manifest_path.write_text(
|
|
"global_enabled_skills: []\n"
|
|
"global_disabled_skills: []\n"
|
|
"agent_enabled_skills: {}\n"
|
|
"agent_disabled_skills: {}\n",
|
|
encoding="utf-8",
|
|
)
|
|
return manifest_path
|
|
|
|
def load_activation_manifest(self, config_name: str) -> Dict[str, object]:
|
|
manifest_path = self.ensure_activation_manifest(config_name)
|
|
with open(manifest_path, "r", encoding="utf-8") as file:
|
|
parsed = yaml.safe_load(file) or {}
|
|
return parsed if isinstance(parsed, dict) else {}
|
|
|
|
def _resolve_source_dir(self, skill_name: str) -> Path:
|
|
customized_dir = self.customized_root / skill_name
|
|
if customized_dir.exists():
|
|
return customized_dir
|
|
|
|
builtin_dir = self.builtin_root / skill_name
|
|
if builtin_dir.exists():
|
|
return builtin_dir
|
|
|
|
raise FileNotFoundError(f"Unknown skill: {skill_name}")
|
|
|
|
def _resolve_agent_skill_source_dir(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
) -> Path:
|
|
"""Resolve one skill from the agent-local workspace or shared registry."""
|
|
for root in (
|
|
self.get_agent_local_root(config_name, agent_id),
|
|
self.get_agent_installed_root(config_name, agent_id),
|
|
):
|
|
candidate = root / skill_name
|
|
if candidate.exists() and (candidate / "SKILL.md").exists():
|
|
return candidate
|
|
return self._resolve_source_dir(skill_name)
|
|
|
|
def _skill_exists_for_agent(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
skill_name: str,
|
|
) -> bool:
|
|
try:
|
|
self._resolve_agent_skill_source_dir(config_name, agent_id, skill_name)
|
|
except FileNotFoundError:
|
|
return False
|
|
return True
|
|
|
|
def _persist_runtime_edits(
|
|
self,
|
|
config_name: str,
|
|
skill_name: str,
|
|
active_dir: Path,
|
|
) -> None:
|
|
"""
|
|
Persist run-time edits from active skills into customized skills.
|
|
|
|
This keeps active skill experiments from being lost on the next reload
|
|
while still allowing the active directory to be re-synced cleanly.
|
|
"""
|
|
if not active_dir.exists():
|
|
return
|
|
|
|
source_dir = self._resolve_source_dir(skill_name)
|
|
if active_dir.resolve() == source_dir.resolve():
|
|
return
|
|
|
|
if not self._directories_match(active_dir, source_dir):
|
|
customized_dir = self.customized_root / skill_name
|
|
customized_dir.parent.mkdir(parents=True, exist_ok=True)
|
|
if customized_dir.exists():
|
|
shutil.rmtree(customized_dir)
|
|
shutil.copytree(active_dir, customized_dir)
|
|
|
|
@staticmethod
|
|
def _directories_match(left: Path, right: Path) -> bool:
|
|
"""Compare two directory trees by file contents."""
|
|
if not left.exists() or not right.exists():
|
|
return False
|
|
|
|
left_items = sorted(
|
|
path.relative_to(left)
|
|
for path in left.rglob("*")
|
|
)
|
|
right_items = sorted(
|
|
path.relative_to(right)
|
|
for path in right.rglob("*")
|
|
)
|
|
if left_items != right_items:
|
|
return False
|
|
|
|
for relative_path in left_items:
|
|
left_path = left / relative_path
|
|
right_path = right / relative_path
|
|
if left_path.is_dir() != right_path.is_dir():
|
|
return False
|
|
if left_path.is_file():
|
|
if left_path.read_bytes() != right_path.read_bytes():
|
|
return False
|
|
return True
|
|
|
|
def resolve_agent_skill_names(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
default_skills: Iterable[str],
|
|
) -> List[str]:
|
|
"""Resolve final skill names after bootstrap and activation overlays."""
|
|
bootstrap = get_bootstrap_config_for_run(self.project_root, config_name)
|
|
override = bootstrap.agent_override(agent_id)
|
|
skills = list(override.get("skills", list(default_skills)))
|
|
agent_config = load_agent_workspace_config(
|
|
self.get_agent_asset_dir(config_name, agent_id) / "agent.yaml",
|
|
)
|
|
|
|
for skill_name in agent_config.enabled_skills:
|
|
if skill_name not in skills:
|
|
skills.append(skill_name)
|
|
|
|
manifest = self.load_activation_manifest(config_name)
|
|
for skill_name in manifest.get("global_enabled_skills", []):
|
|
if skill_name not in skills:
|
|
skills.append(skill_name)
|
|
|
|
for skill_name in manifest.get("agent_enabled_skills", {}).get(agent_id, []):
|
|
if skill_name not in skills:
|
|
skills.append(skill_name)
|
|
|
|
disabled = set(manifest.get("global_disabled_skills", []))
|
|
disabled.update(
|
|
manifest.get("agent_disabled_skills", {}).get(agent_id, []),
|
|
)
|
|
disabled.update(agent_config.disabled_skills)
|
|
|
|
for item in self.list_agent_local_skills(config_name, agent_id):
|
|
if item.skill_name not in skills:
|
|
skills.append(item.skill_name)
|
|
|
|
return [
|
|
skill
|
|
for skill in skills
|
|
if skill not in disabled
|
|
and self._skill_exists_for_agent(config_name, agent_id, skill)
|
|
]
|
|
|
|
def sync_skill_dirs(
|
|
self,
|
|
target_root: Path,
|
|
skill_sources: Dict[str, Path],
|
|
) -> List[Path]:
|
|
"""Sync selected skill directories into one target root."""
|
|
target_root.mkdir(parents=True, exist_ok=True)
|
|
|
|
synced_paths: List[Path] = []
|
|
wanted = set(skill_sources)
|
|
|
|
for existing in target_root.iterdir():
|
|
if existing.is_dir() and existing.name not in wanted:
|
|
shutil.rmtree(existing)
|
|
|
|
for skill_name, source_dir in skill_sources.items():
|
|
target_dir = target_root / skill_name
|
|
if target_dir.exists():
|
|
shutil.rmtree(target_dir)
|
|
shutil.copytree(source_dir, target_dir)
|
|
synced_paths.append(target_dir)
|
|
|
|
return synced_paths
|
|
|
|
def sync_active_skills(
|
|
self,
|
|
target_root: Path,
|
|
skill_names: Iterable[str],
|
|
) -> List[Path]:
|
|
"""Sync selected shared skills into one active directory."""
|
|
skill_sources = {
|
|
skill_name: self._resolve_source_dir(skill_name)
|
|
for skill_name in skill_names
|
|
}
|
|
return self.sync_skill_dirs(target_root, skill_sources)
|
|
|
|
def prepare_active_skills(
|
|
self,
|
|
config_name: str,
|
|
agent_defaults: Dict[str, Iterable[str]],
|
|
) -> Dict[str, List[Path]]:
|
|
"""Resolve all agent skills into per-agent installed/active workspaces."""
|
|
resolved: Dict[str, List[str]] = {}
|
|
union: List[str] = []
|
|
|
|
for agent_id, default_skills in agent_defaults.items():
|
|
resolved_skills = self.resolve_agent_skill_names(
|
|
config_name=config_name,
|
|
agent_id=agent_id,
|
|
default_skills=default_skills,
|
|
)
|
|
resolved[agent_id] = resolved_skills
|
|
for skill_name in resolved_skills:
|
|
if skill_name not in union:
|
|
union.append(skill_name)
|
|
|
|
# Maintain the legacy union directory for compatibility/debugging.
|
|
# Agent-local skills remain private to the agent workspace.
|
|
self.sync_active_skills(
|
|
target_root=self.get_active_root(config_name),
|
|
skill_names=[
|
|
skill_name
|
|
for skill_name in union
|
|
if self._is_shared_skill(skill_name)
|
|
],
|
|
)
|
|
|
|
active_map: Dict[str, List[Path]] = {}
|
|
for agent_id, skill_names in resolved.items():
|
|
installed_sources = {
|
|
skill_name: self._resolve_source_dir(skill_name)
|
|
for skill_name in skill_names
|
|
if (self.get_agent_local_root(config_name, agent_id) / skill_name).exists() is False
|
|
}
|
|
installed_paths = self.sync_skill_dirs(
|
|
target_root=self.get_agent_installed_root(config_name, agent_id),
|
|
skill_sources=installed_sources,
|
|
)
|
|
|
|
local_root = self.get_agent_local_root(config_name, agent_id)
|
|
local_sources = {
|
|
skill_name: local_root / skill_name
|
|
for skill_name in skill_names
|
|
if (local_root / skill_name).exists()
|
|
}
|
|
active_sources = {
|
|
path.name: path for path in installed_paths
|
|
}
|
|
active_sources.update(local_sources)
|
|
active_map[agent_id] = self.sync_skill_dirs(
|
|
target_root=self.get_agent_active_root(config_name, agent_id),
|
|
skill_sources=active_sources,
|
|
)
|
|
|
|
disabled_names = _dedupe_preserve_order(
|
|
self._resolve_disabled_skill_names(
|
|
config_name=config_name,
|
|
agent_id=agent_id,
|
|
default_skills=agent_defaults.get(agent_id, []),
|
|
),
|
|
)
|
|
disabled_sources = {
|
|
skill_name: self._resolve_agent_skill_source_dir(
|
|
config_name=config_name,
|
|
agent_id=agent_id,
|
|
skill_name=skill_name,
|
|
)
|
|
for skill_name in disabled_names
|
|
}
|
|
self.sync_skill_dirs(
|
|
target_root=self.get_agent_disabled_root(config_name, agent_id),
|
|
skill_sources=disabled_sources,
|
|
)
|
|
|
|
return active_map
|
|
|
|
def _is_shared_skill(self, skill_name: str) -> bool:
|
|
try:
|
|
self._resolve_source_dir(skill_name)
|
|
except FileNotFoundError:
|
|
return False
|
|
return True
|
|
|
|
def _resolve_disabled_skill_names(
|
|
self,
|
|
config_name: str,
|
|
agent_id: str,
|
|
default_skills: Iterable[str],
|
|
) -> List[str]:
|
|
"""Resolve explicit disabled skills for one agent."""
|
|
bootstrap = get_bootstrap_config_for_run(self.project_root, config_name)
|
|
override = bootstrap.agent_override(agent_id)
|
|
baseline = list(override.get("skills", list(default_skills)))
|
|
agent_config = load_agent_workspace_config(
|
|
self.get_agent_asset_dir(config_name, agent_id) / "agent.yaml",
|
|
)
|
|
manifest = self.load_activation_manifest(config_name)
|
|
disabled = list(manifest.get("global_disabled_skills", []))
|
|
disabled.extend(manifest.get("agent_disabled_skills", {}).get(agent_id, []))
|
|
disabled.extend(agent_config.disabled_skills)
|
|
for skill_name in baseline:
|
|
if skill_name in agent_config.disabled_skills and skill_name not in disabled:
|
|
disabled.append(skill_name)
|
|
for item in self.list_agent_local_skills(config_name, agent_id):
|
|
if item.skill_name in agent_config.disabled_skills and item.skill_name not in disabled:
|
|
disabled.append(item.skill_name)
|
|
return [
|
|
skill
|
|
for skill in disabled
|
|
if self._skill_exists_for_agent(config_name, agent_id, skill)
|
|
]
|
|
|
|
|
|
def _dedupe_preserve_order(items: Iterable[str]) -> List[str]:
|
|
result: List[str] = []
|
|
for item in items:
|
|
if item not in result:
|
|
result.append(item)
|
|
return result
|
|
|
|
|
|
def _normalize_skill_name(raw_name: str) -> str:
|
|
normalized = str(raw_name or "").strip().lower().replace(" ", "_").replace("-", "_")
|
|
allowed = [ch for ch in normalized if ch.isalnum() or ch == "_"]
|
|
return "".join(allowed).strip("_")
|