fcp-python 0.1.0__py3-none-any.whl

fcp_python/main.py

@@ -0,0 +1,288 @@
+"""fcp-python — Python Code Intelligence FCP MCP server."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from fcp_core import VerbRegistry, suggest
+
+from fcp_python.domain.format import format_error
+from fcp_python.domain.model import PythonModel
+from fcp_python.domain.mutation import dispatch_mutation
+from fcp_python.domain.query import dispatch_query
+from fcp_python.domain.verbs import (
+    register_mutation_verbs,
+    register_query_verbs,
+    register_session_verbs,
+)
+from fcp_python.lsp.client import LspClient
+from fcp_python.lsp.lifecycle import ServerStatus
+from fcp_python.lsp.types import PublishDiagnosticsParams, SymbolInformation
+from fcp_python.resolver.index import SymbolEntry, SymbolIndex
+
+mcp = FastMCP(
+    "python-fcp",
+    instructions=(
+        "FCP Python server for querying Python codebases via pylsp. "
+        "Use python_session to open a workspace, python_query for read-only queries, "
+        "and python_help for the reference card."
+    ),
+)
+
+# Global state
+_model = PythonModel("file:///")
+_lock = asyncio.Lock()
+
+
+def _make_registry() -> VerbRegistry:
+    reg = VerbRegistry()
+    register_query_verbs(reg)
+    register_mutation_verbs(reg)
+    register_session_verbs(reg)
+    return reg
+
+
+_registry = _make_registry()
+
+
+@mcp.tool(
+    description=(
+        "Execute Python mutation operations. Examples: "
+        "'rename Config Settings', "
+        "'extract validate @file:server.py @lines:15-30', "
+        "'import os @file:main.py @line:5'"
+    )
+)
+async def python(ops: list[str]) -> str:
+    """Execute mutation operations."""
+    async with _lock:
+        results = []
+        for op in ops:
+            result = await dispatch_mutation(_model, _registry, op)
+            results.append(result)
+        return "\n\n".join(results)
+
+
+@mcp.tool(
+    description=(
+        "Execute a read-only FCP query on the Python workspace. Examples: "
+        "'find Config', 'def main @file:main.py', 'diagnose', 'unused', 'map'"
+    )
+)
+async def python_query(input: str) -> str:
+    """Execute a read-only query."""
+    async with _lock:
+        return await dispatch_query(_model, _registry, input)
+
+
+@mcp.tool(
+    description=(
+        "Manage the Python workspace session. Actions: "
+        "'open PATH' to open a workspace, "
+        "'status' to check server status, "
+        "'close' to close the workspace."
+    )
+)
+async def python_session(action: str) -> str:
+    """Manage workspace session."""
+    async with _lock:
+        return await _handle_session(action)
+
+
+@mcp.tool(
+    description="Show the FCP Python reference card with all available verbs and their syntax."
+)
+async def python_help() -> str:
+    """Show reference card."""
+    extra = {
+        "Selectors": (
+            "  @file:PATH      — filter by file path\n"
+            "  @class:NAME     — filter by containing class\n"
+            "  @kind:KIND      — filter by symbol kind (function, class, method, variable, ...)\n"
+            "  @module:NAME    — filter by module\n"
+            "  @line:N         — filter by line number\n"
+            "  @lines:N-M      — line range for extract\n"
+            "  @decorator:NAME — filter by decorator"
+        ),
+        "Mutation Examples": (
+            '  python ["rename Config Settings"]              — cross-file semantic rename\n'
+            '  python ["extract validate @file:server.py @lines:15-30"] — extract function\n'
+            '  python ["import os @file:main.py @line:5"]     — add missing import'
+        ),
+    }
+    return _registry.generate_reference_card(extra)
+
+
+async def _handle_session(action: str) -> str:
+    global _model
+    tokens = action.split()
+    if not tokens:
+        return "! empty session action."
+
+    cmd = tokens[0]
+    if cmd == "open":
+        if len(tokens) < 2:
+            return "! open requires a path."
+        return await _handle_open(tokens[1])
+    elif cmd == "status":
+        return _handle_status()
+    elif cmd == "close":
+        return await _handle_close()
+    else:
+        return f"! unknown session action '{cmd}'."
+
+
+async def _handle_open(path: str) -> str:
+    global _model
+
+    if path.startswith("file://"):
+        uri = path
+    else:
+        p = Path(path).resolve()
+        if not p.exists():
+            return f"! path not found: {path}"
+        uri = p.as_uri()
+
+    try:
+        client = await LspClient.spawn("pylsp", [], uri)
+    except Exception as e:
+        return f"! failed to start pylsp: {e}"
+
+    _model = PythonModel(uri)
+    _model.lsp_client = client
+    _model.server_status = ServerStatus.Ready
+    _model.py_file_count = _count_py_files(path)
+
+    # Start notification handler
+    asyncio.create_task(_notification_handler(client.notification_queue, _model))
+
+    # Populate initial index
+    symbol_count = await _populate_initial_index(client, _model)
+
+    _model.last_reload = time.time()
+
+    return f"Opened workspace: {path} ({_model.py_file_count} files, {symbol_count} symbols)"
+
+
+def _handle_status() -> str:
+    status_str = _model.server_status.name
+    errors, warnings = _model.total_diagnostics()
+    return (
+        f"Status: {status_str}\n"
+        f"Workspace: {_model.root_uri}\n"
+        f"Files: {_model.py_file_count}\n"
+        f"Symbols: {_model.symbol_index.size()}\n"
+        f"Diagnostics: {errors} errors, {warnings} warnings"
+    )
+
+
+async def _handle_close() -> str:
+    global _model
+    if _model.lsp_client:
+        try:
+            await _model.lsp_client.shutdown()
+        except Exception:
+            pass
+
+    _model.server_status = ServerStatus.Stopped
+    _model.lsp_client = None
+    _model.symbol_index = SymbolIndex()
+    _model.diagnostics.clear()
+    _model.open_documents.clear()
+
+    return "Workspace closed."
+
+
+async def _notification_handler(
+    queue: asyncio.Queue,
+    model: PythonModel,
+) -> None:
+    """Process LSP notifications (diagnostics etc)."""
+    while True:
+        try:
+            notif = await queue.get()
+        except Exception:
+            break
+        if notif.method == "textDocument/publishDiagnostics":
+            if notif.params:
+                try:
+                    params = PublishDiagnosticsParams.from_dict(notif.params)
+                    model.update_diagnostics(params.uri, params.diagnostics)
+                except Exception:
+                    pass
+
+
+async def _populate_initial_index(client: LspClient, model: PythonModel) -> int:
+    """Populate symbol index with workspace/symbol query, with retries."""
+    for attempt in range(10):
+        try:
+            raw_symbols = await client.request("workspace/symbol", {"query": "*"})
+            if raw_symbols:
+                for sym_dict in raw_symbols:
+                    sym = SymbolInformation.from_dict(sym_dict)
+                    model.symbol_index.insert(SymbolEntry(
+                        name=sym.name,
+                        kind=sym.kind,
+                        container_name=sym.container_name,
+                        uri=sym.location.uri,
+                        range=sym.location.range,
+                        selection_range=sym.location.range,
+                    ))
+                return len(raw_symbols)
+        except Exception:
+            pass
+        if attempt < 9:
+            await asyncio.sleep(0.5)
+    return 0
+
+
+def _count_py_files(path: str) -> int:
+    """Count .py files in directory, skipping hidden dirs and __pycache__."""
+    if not os.path.isdir(path):
+        return 0
+    skip_dirs = {"__pycache__", "node_modules", ".venv", "venv"}
+    count = 0
+    try:
+        for entry in os.scandir(path):
+            if entry.is_dir(follow_symlinks=False):
+                if entry.name.startswith(".") or entry.name in skip_dirs:
+                    continue
+                count += _count_py_files(entry.path)
+            elif entry.name.endswith(".py"):
+                count += 1
+    except PermissionError:
+        pass
+    return count
+
+
+def main() -> None:
+    # Spawn slipstream bridge in background (silent no-op if daemon not running)
+    from fcp_python.bridge import start_bridge
+
+    async def _bridge_session(action: str) -> str:
+        async with _lock:
+            return await _handle_session(action)
+
+    async def _bridge_query(q: str) -> str:
+        async with _lock:
+            return await dispatch_query(_model, _registry, q)
+
+    async def _bridge_mutation(ops: list[str]) -> str:
+        async with _lock:
+            results = []
+            for op in ops:
+                results.append(await dispatch_mutation(_model, _registry, op))
+            return "\n\n".join(results)
+
+    start_bridge(_bridge_session, _bridge_query, _bridge_mutation)
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

fcp_python/resolver/__init__.py

@@ -0,0 +1,25 @@
+"""Resolver layer: symbol indexing, selector filtering, resolution pipeline."""
+
+from fcp_python.resolver.index import SymbolEntry, SymbolIndex
+from fcp_python.resolver.selectors import (
+    ParsedSelector,
+    SelectorType,
+    filter_by_selectors,
+    parse_line_range,
+    parse_selector,
+    symbol_kind_from_string,
+)
+from fcp_python.resolver.pipeline import ResolveResult, SymbolResolver
+
+__all__ = [
+    "SymbolEntry",
+    "SymbolIndex",
+    "ParsedSelector",
+    "SelectorType",
+    "filter_by_selectors",
+    "parse_line_range",
+    "parse_selector",
+    "symbol_kind_from_string",
+    "ResolveResult",
+    "SymbolResolver",
+]

fcp_python/resolver/index.py

@@ -0,0 +1,55 @@
+"""Triple-indexed symbol cache for fast resolution lookups."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from fcp_python.lsp.types import Range, SymbolKind
+
+
+@dataclass
+class SymbolEntry:
+    name: str
+    kind: SymbolKind
+    container_name: str | None
+    uri: str
+    range: Range
+    selection_range: Range
+
+
+class SymbolIndex:
+    """Triple-indexed symbol store: by name, by file URI, by container."""
+
+    def __init__(self) -> None:
+        self._by_name: dict[str, list[SymbolEntry]] = {}
+        self._by_file: dict[str, list[SymbolEntry]] = {}
+        self._by_container: dict[str, list[SymbolEntry]] = {}
+
+    def insert(self, entry: SymbolEntry) -> None:
+        self._by_name.setdefault(entry.name, []).append(entry)
+        self._by_file.setdefault(entry.uri, []).append(entry)
+        if entry.container_name is not None:
+            self._by_container.setdefault(entry.container_name, []).append(entry)
+
+    def lookup_by_name(self, name: str) -> list[SymbolEntry]:
+        return list(self._by_name.get(name, []))
+
+    def lookup_by_file(self, uri: str) -> list[SymbolEntry]:
+        return list(self._by_file.get(uri, []))
+
+    def lookup_by_container(self, container: str) -> list[SymbolEntry]:
+        return list(self._by_container.get(container, []))
+
+    def invalidate_file(self, uri: str) -> None:
+        self._by_file.pop(uri, None)
+
+        for entries in self._by_name.values():
+            entries[:] = [e for e in entries if e.uri != uri]
+        self._by_name = {k: v for k, v in self._by_name.items() if v}
+
+        for entries in self._by_container.values():
+            entries[:] = [e for e in entries if e.uri != uri]
+        self._by_container = {k: v for k, v in self._by_container.items() if v}
+
+    def size(self) -> int:
+        return sum(len(v) for v in self._by_file.values())

fcp_python/resolver/pipeline.py

@@ -0,0 +1,105 @@
+"""3-tier symbol resolution pipeline."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+from fcp_python.lsp.types import Location, SymbolInformation
+from fcp_python.resolver.index import SymbolEntry, SymbolIndex
+from fcp_python.resolver.selectors import ParsedSelector, filter_by_selectors
+
+
+class _ResultKind(Enum):
+    FOUND = auto()
+    AMBIGUOUS = auto()
+    NOT_FOUND = auto()
+
+
+class ResolveResult:
+    """Tagged union: Found(entry), Ambiguous(entries), NotFound."""
+
+    def __init__(self, kind: _ResultKind, entry: SymbolEntry | None = None, entries: list[SymbolEntry] | None = None):
+        self._kind = kind
+        self._entry = entry
+        self._entries = entries
+
+    @staticmethod
+    def found(entry: SymbolEntry) -> ResolveResult:
+        return ResolveResult(_ResultKind.FOUND, entry=entry)
+
+    @staticmethod
+    def ambiguous(entries: list[SymbolEntry]) -> ResolveResult:
+        return ResolveResult(_ResultKind.AMBIGUOUS, entries=entries)
+
+    @staticmethod
+    def not_found() -> ResolveResult:
+        return ResolveResult(_ResultKind.NOT_FOUND)
+
+    @property
+    def is_found(self) -> bool:
+        return self._kind == _ResultKind.FOUND
+
+    @property
+    def is_ambiguous(self) -> bool:
+        return self._kind == _ResultKind.AMBIGUOUS
+
+    @property
+    def is_not_found(self) -> bool:
+        return self._kind == _ResultKind.NOT_FOUND
+
+    @property
+    def entry(self) -> SymbolEntry:
+        assert self._kind == _ResultKind.FOUND and self._entry is not None
+        return self._entry
+
+    @property
+    def entries(self) -> list[SymbolEntry]:
+        assert self._kind == _ResultKind.AMBIGUOUS and self._entries is not None
+        return self._entries
+
+
+def _entry_to_symbol_info(entry: SymbolEntry) -> SymbolInformation:
+    return SymbolInformation(
+        name=entry.name,
+        kind=entry.kind,
+        location=Location(uri=entry.uri, range=entry.range),
+        container_name=entry.container_name,
+    )
+
+
+class SymbolResolver:
+    """Multi-tier symbol resolver."""
+
+    def __init__(self, index: SymbolIndex) -> None:
+        self._index = index
+
+    def resolve_from_index(
+        self,
+        name: str,
+        selectors: list[ParsedSelector],
+    ) -> ResolveResult:
+        """Tier 1: resolve from in-memory index with selector filtering."""
+        entries = self._index.lookup_by_name(name)
+
+        if not entries:
+            return ResolveResult.not_found()
+
+        if selectors:
+            sym_infos = [_entry_to_symbol_info(e) for e in entries]
+            filtered_infos = filter_by_selectors(sym_infos, selectors)
+            # Map back to entries by matching indices
+            filtered_info_set = set(id(si) for si in filtered_infos)
+            filtered = [
+                e for e, si in zip(entries, sym_infos)
+                if id(si) in filtered_info_set
+            ]
+        else:
+            filtered = entries
+
+        if len(filtered) == 0:
+            return ResolveResult.not_found()
+        elif len(filtered) == 1:
+            return ResolveResult.found(filtered[0])
+        else:
+            return ResolveResult.ambiguous(filtered)

fcp_python/resolver/selectors.py

@@ -0,0 +1,161 @@
+"""Selector parsing and filtering for symbol resolution."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from fcp_python.lsp.types import SymbolInformation, SymbolKind
+
+
+class SelectorType(Enum):
+    FILE = "file"
+    CLASS = "class"
+    KIND = "kind"
+    MODULE = "module"
+    LINE = "line"
+    LINES = "lines"
+    DECORATOR = "decorator"
+
+
+@dataclass
+class ParsedSelector:
+    selector_type: SelectorType
+    value: str
+
+
+def parse_selector(selector: str) -> ParsedSelector | None:
+    """Parse @type:value selector string.
+
+    Maps: @file:PATH, @class:NAME (@struct:NAME alias),
+    @kind:KIND, @module:NAME (@mod:NAME alias),
+    @line:N, @lines:N-M, @decorator:NAME
+    """
+    if not selector.startswith("@"):
+        return None
+
+    rest = selector[1:]
+    colon_idx = rest.find(":")
+    if colon_idx == -1:
+        return None
+
+    type_str = rest[:colon_idx]
+    value = rest[colon_idx + 1:]
+
+    type_map: dict[str, SelectorType] = {
+        "file": SelectorType.FILE,
+        "class": SelectorType.CLASS,
+        "struct": SelectorType.CLASS,  # Rust compat alias
+        "kind": SelectorType.KIND,
+        "module": SelectorType.MODULE,
+        "mod": SelectorType.MODULE,
+        "line": SelectorType.LINE,
+        "lines": SelectorType.LINES,
+        "decorator": SelectorType.DECORATOR,
+    }
+
+    selector_type = type_map.get(type_str)
+    if selector_type is None:
+        return None
+
+    return ParsedSelector(selector_type=selector_type, value=value)
+
+
+def filter_by_selectors(
+    symbols: list[SymbolInformation],
+    selectors: list[ParsedSelector],
+) -> list[SymbolInformation]:
+    """Filter symbols by selectors (AND logic)."""
+    return [
+        sym for sym in symbols
+        if all(_matches_selector(sym, sel) for sel in selectors)
+    ]
+
+
+def _matches_selector(sym: SymbolInformation, sel: ParsedSelector) -> bool:
+    match sel.selector_type:
+        case SelectorType.FILE:
+            return sel.value in sym.location.uri
+        case SelectorType.CLASS:
+            return (
+                sym.container_name == sel.value
+                or (sym.name == sel.value and sym.kind == SymbolKind.Class)
+            )
+        case SelectorType.KIND:
+            kind = symbol_kind_from_string(sel.value)
+            return kind is not None and sym.kind == kind
+        case SelectorType.MODULE:
+            container_match = (
+                sym.container_name is not None and sel.value in sym.container_name
+            )
+            return container_match or sel.value in sym.location.uri
+        case SelectorType.LINE:
+            try:
+                line = int(sel.value)
+            except ValueError:
+                return False
+            return sym.location.range.start.line <= line <= sym.location.range.end.line
+        case SelectorType.LINES:
+            # Consumed by mutation handlers, not symbol filtering
+            return True
+        case SelectorType.DECORATOR:
+            # Would need AST analysis; pass-through for now
+            return True
+
+
+def parse_line_range(value: str) -> tuple[int, int] | None:
+    """Parse '15-30' into (15, 30). Returns None if invalid."""
+    parts = value.split("-", 1)
+    if len(parts) != 2:
+        return None
+    try:
+        start = int(parts[0])
+        end = int(parts[1])
+    except ValueError:
+        return None
+    if start > end:
+        return None
+    return (start, end)
+
+
+def symbol_kind_from_string(s: str) -> SymbolKind | None:
+    """Convert string to SymbolKind. Python-specific additions included."""
+    mapping: dict[str, SymbolKind] = {
+        "function": SymbolKind.Function,
+        "fn": SymbolKind.Function,
+        "def": SymbolKind.Function,
+        "method": SymbolKind.Method,
+        "class": SymbolKind.Class,
+        "struct": SymbolKind.Struct,
+        "enum": SymbolKind.Enum,
+        "interface": SymbolKind.Interface,
+        "trait": SymbolKind.Interface,
+        "variable": SymbolKind.Variable,
+        "var": SymbolKind.Variable,
+        "constant": SymbolKind.Constant,
+        "const": SymbolKind.Constant,
+        "property": SymbolKind.Property,
+        "module": SymbolKind.Module,
+        "mod": SymbolKind.Module,
+        "namespace": SymbolKind.Namespace,
+        "field": SymbolKind.Field,
+        "constructor": SymbolKind.Constructor,
+        "type_parameter": SymbolKind.TypeParameter,
+        "typeparameter": SymbolKind.TypeParameter,
+        "file": SymbolKind.File,
+        "package": SymbolKind.Package,
+        "string": SymbolKind.String,
+        "number": SymbolKind.Number,
+        "boolean": SymbolKind.Boolean,
+        "bool": SymbolKind.Boolean,
+        "array": SymbolKind.Array,
+        "object": SymbolKind.Object,
+        "key": SymbolKind.Key,
+        "null": SymbolKind.Null,
+        "enum_member": SymbolKind.EnumMember,
+        "enummember": SymbolKind.EnumMember,
+        "event": SymbolKind.Event,
+        "operator": SymbolKind.Operator,
+        "decorator": SymbolKind.Function,  # decorators are functions
+    }
+    return mapping.get(s.lower())

fcp_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: fcp-python
+Version: 0.1.0
+Summary: Python Code Intelligence FCP — semantic Python code operations for LLMs via pylsp
+Requires-Python: <3.14,>=3.11
+Requires-Dist: fastmcp>=3.0
+Requires-Dist: fcp-core>=0.1.17
+Requires-Dist: python-lsp-server[rope]>=1.12

fcp_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+fcp_python/__init__.py,sha256=jXbt2O90IFhcdC8JQ4qr2zYFSlz1Zvpml9hEam5JstU,58
+fcp_python/bridge.py,sha256=KLfOkCdZR-KJsKzvnsus7PgLCbjrWK3NmTYFV-0hdEU,5680
+fcp_python/main.py,sha256=nc_tjq8GfXXBJavLQP7ey6s_ROs7fOUyCYtnaSkx_6Q,8787
+fcp_python/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fcp_python/domain/format.py,sha256=9oHtn3d9vvRT28DrJxNs9m-YpIWjfjIr-pMWF5Tu4v0,7311
+fcp_python/domain/model.py,sha256=yI2kVvEWv50wICqqmrHV_302EVMtZd_t1v1X50ZonO8,1458
+fcp_python/domain/mutation.py,sha256=ggkm-4zY9rTHfNYYWEcfGNok14MFXUS6_nsBVXaQqoU,12578
+fcp_python/domain/query.py,sha256=KFve1HFAKwyHJPgT1INEQ97jieUUDvhswho-NHqrxkc,21706
+fcp_python/domain/verbs.py,sha256=3u2SJ5do1UKXSA39KaCDvdTkhMXHpUAhm363kEQKDXs,1919
+fcp_python/lsp/__init__.py,sha256=Kai6_M5ap1qjrLEfpkdcVZenIzQDQHMUu28JscQg_kM,39
+fcp_python/lsp/client.py,sha256=H-I1Hq8ayAUimGcsMpiLmFZcdYHRvQBL0jYG--F51JU,6428
+fcp_python/lsp/lifecycle.py,sha256=i-b61LGOeQxZIUjUAf_oR8nMqS7rnGR52EYb9KM3zHc,2774
+fcp_python/lsp/transport.py,sha256=XN3vOMa3aT_uBh_-s05mxxwf4w_YF9n3a-D7tJS578k,3616
+fcp_python/lsp/types.py,sha256=aj_5U-dHX-pXMjW6UerYGdQV8lwT8kHn58U26R0Cgm4,13332
+fcp_python/lsp/workspace_edit.py,sha256=WDT1bsPW38fI2k4_SaMpHONBds96oTKBlIPiVhVDixA,4204
+fcp_python/resolver/__init__.py,sha256=9ImXXfUvA0TWGDZx1GMniKzav7SKT9q9u1C_0EOZE9w,637
+fcp_python/resolver/index.py,sha256=9y56ZoBNqwl8a4_Ue54ZBjNWzj3kZ548miIZvab_90k,1859
+fcp_python/resolver/pipeline.py,sha256=cPqawRgQ3hxNKottcsco1RGLT4f2c3IWidqnuSzhh7c,3174
+fcp_python/resolver/selectors.py,sha256=u_NQdp6eU2fPSKnSpWNhTZbxwy6OgvxVTR3pKdB_7Rg,5070
+fcp_python-0.1.0.dist-info/METADATA,sha256=mwRqNS2f4dkcGWab_RdZ2PBcgB0Y85MK6n1yMOf2sUM,282
+fcp_python-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fcp_python-0.1.0.dist-info/entry_points.txt,sha256=iSyoGO8uLz21KTX8mL3twnRXWsuc7-8O3U03WCSiJ_s,52
+fcp_python-0.1.0.dist-info/RECORD,,

fcp_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fcp_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fcp-python = fcp_python.main:main