778 lines
27 KiB
Python
778 lines
27 KiB
Python
from __future__ import annotations
|
|
|
|
import fnmatch
|
|
import ftplib
|
|
import posixpath
|
|
import tempfile
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
from urllib.parse import quote, unquote, urlparse
|
|
|
|
from ProviderCore.base import Provider, SearchResult, parse_inline_query_arguments
|
|
|
|
|
|
def _pick_provider_config(config: Any) -> Dict[str, Any]:
|
|
if not isinstance(config, dict):
|
|
return {}
|
|
provider = config.get("provider")
|
|
if not isinstance(provider, dict):
|
|
return {}
|
|
entry = provider.get("ftp")
|
|
if isinstance(entry, dict):
|
|
return entry
|
|
return {}
|
|
|
|
|
|
def _coerce_bool(value: Any, default: bool = False) -> bool:
|
|
if isinstance(value, bool):
|
|
return value
|
|
if value is None:
|
|
return default
|
|
text = str(value).strip().lower()
|
|
if not text:
|
|
return default
|
|
if text in {"1", "true", "yes", "on"}:
|
|
return True
|
|
if text in {"0", "false", "no", "off"}:
|
|
return False
|
|
return default
|
|
|
|
|
|
def _coerce_int(value: Any, default: int) -> int:
|
|
try:
|
|
return int(value)
|
|
except Exception:
|
|
return default
|
|
|
|
|
|
def _format_timestamp(raw_value: Any) -> str:
|
|
text = str(raw_value or "").strip()
|
|
if not text:
|
|
return ""
|
|
for pattern in ("%Y%m%d%H%M%S", "%Y%m%d%H%M%S.%f"):
|
|
try:
|
|
parsed = datetime.strptime(text, pattern)
|
|
return parsed.strftime("%Y-%m-%d %H:%M")
|
|
except Exception:
|
|
continue
|
|
return text
|
|
|
|
|
|
def _safe_filename(name: Any) -> str:
|
|
raw = str(name or "").strip()
|
|
if not raw:
|
|
raw = "download"
|
|
cleaned = "".join(ch if ch.isalnum() or ch in {"-", "_", ".", " "} else "_" for ch in raw)
|
|
cleaned = cleaned.strip(" ._")
|
|
return cleaned or "download"
|
|
|
|
|
|
def _unique_path(path: Path) -> Path:
|
|
if not path.exists():
|
|
return path
|
|
stem = path.stem or "download"
|
|
suffix = path.suffix
|
|
counter = 1
|
|
while True:
|
|
candidate = path.with_name(f"{stem}_{counter}{suffix}")
|
|
if not candidate.exists():
|
|
return candidate
|
|
counter += 1
|
|
|
|
|
|
class FTP(Provider):
|
|
PLUGIN_NAME = "ftp"
|
|
URL = ("ftp://", "ftps://")
|
|
|
|
@property
|
|
def label(self) -> str:
|
|
return "FTP"
|
|
|
|
@property
|
|
def preserve_order(self) -> bool:
|
|
return True
|
|
|
|
@classmethod
|
|
def config_schema(cls) -> List[Dict[str, Any]]:
|
|
return [
|
|
{
|
|
"key": "host",
|
|
"label": "Host",
|
|
"default": "",
|
|
"required": True,
|
|
"placeholder": "ftp.example.com",
|
|
},
|
|
{
|
|
"key": "port",
|
|
"label": "Port",
|
|
"type": "integer",
|
|
"default": 21,
|
|
},
|
|
{
|
|
"key": "username",
|
|
"label": "Username",
|
|
"default": "anonymous",
|
|
},
|
|
{
|
|
"key": "password",
|
|
"label": "Password",
|
|
"type": "secret",
|
|
"secret": True,
|
|
"default": "",
|
|
},
|
|
{
|
|
"key": "base_path",
|
|
"label": "Base Path",
|
|
"default": "/",
|
|
"placeholder": "/incoming",
|
|
},
|
|
{
|
|
"key": "tls",
|
|
"label": "Use FTPS",
|
|
"type": "boolean",
|
|
"default": False,
|
|
},
|
|
{
|
|
"key": "passive",
|
|
"label": "Passive Mode",
|
|
"type": "boolean",
|
|
"default": True,
|
|
},
|
|
{
|
|
"key": "timeout",
|
|
"label": "Timeout Seconds",
|
|
"type": "integer",
|
|
"default": 20,
|
|
},
|
|
{
|
|
"key": "search_depth",
|
|
"label": "Default Search Depth",
|
|
"type": "integer",
|
|
"default": 1,
|
|
},
|
|
]
|
|
|
|
def __init__(self, config: Optional[Dict[str, Any]] = None):
|
|
super().__init__(config)
|
|
conf = _pick_provider_config(self.config)
|
|
self._host = str(conf.get("host") or "").strip()
|
|
self._tls = _coerce_bool(conf.get("tls"), False)
|
|
self._port = _coerce_int(conf.get("port"), 21)
|
|
self._username = str(conf.get("username") or conf.get("user") or "anonymous").strip() or "anonymous"
|
|
password_value = conf.get("password")
|
|
self._password = str(password_value).strip() if password_value not in (None, "") else "anonymous@"
|
|
self._passive = _coerce_bool(conf.get("passive"), True)
|
|
self._timeout = max(1, _coerce_int(conf.get("timeout"), 20))
|
|
self._search_depth = max(0, _coerce_int(conf.get("search_depth"), 1))
|
|
self._base_path = self._normalize_remote_path(conf.get("base_path") or "/", default="/")
|
|
|
|
def validate(self) -> bool:
|
|
return bool(self._host)
|
|
|
|
def config_helper_text(self) -> str:
|
|
return "Test the configured FTP/FTPS settings before searching or uploading."
|
|
|
|
def config_actions(self) -> List[Dict[str, Any]]:
|
|
return [
|
|
{
|
|
"id": "test_connection",
|
|
"label": "Test connection",
|
|
"variant": "primary",
|
|
}
|
|
]
|
|
|
|
def run_config_action(self, action_id: str, **_kwargs: Any) -> Dict[str, Any]:
|
|
if str(action_id or "").strip().lower() != "test_connection":
|
|
return super().run_config_action(action_id, **_kwargs)
|
|
|
|
if not self._host:
|
|
return {"ok": False, "message": "Set 'host' before testing the FTP connection."}
|
|
|
|
ftp = None
|
|
try:
|
|
ftp = self._connect()
|
|
active_path = self._base_path or "/"
|
|
try:
|
|
ftp.cwd(active_path)
|
|
resolved_path = ftp.pwd()
|
|
except Exception:
|
|
resolved_path = active_path
|
|
return {
|
|
"ok": True,
|
|
"message": f"Connected to FTP {self._host}:{self._port} and reached {resolved_path}.",
|
|
}
|
|
except Exception as exc:
|
|
return {"ok": False, "message": f"FTP connection failed: {exc}"}
|
|
finally:
|
|
self._close(ftp)
|
|
|
|
def extract_query_arguments(self, query: str) -> Tuple[str, Dict[str, Any]]:
|
|
text, inline = parse_inline_query_arguments(query)
|
|
filters: Dict[str, Any] = {}
|
|
|
|
if inline.get("path"):
|
|
filters["path"] = inline.get("path")
|
|
if inline.get("depth"):
|
|
filters["depth"] = max(0, _coerce_int(inline.get("depth"), self._search_depth))
|
|
if inline.get("type"):
|
|
filters["type"] = str(inline.get("type") or "").strip().lower()
|
|
|
|
return text, filters
|
|
|
|
def get_table_title(self, query: str, filters: Optional[Dict[str, Any]] = None) -> str:
|
|
active_path = self._normalize_remote_path((filters or {}).get("path") or self._base_path, default=self._base_path)
|
|
text = str(query or "").strip()
|
|
if not text or text == "*":
|
|
return f"FTP: {active_path}"
|
|
return f"FTP: {text} @ {active_path}"
|
|
|
|
def get_table_metadata(self, query: str, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
|
|
return {
|
|
"plugin": self.name,
|
|
"host": self._host,
|
|
"path": self._normalize_remote_path((filters or {}).get("path") or self._base_path, default=self._base_path),
|
|
"query": str(query or "").strip(),
|
|
}
|
|
|
|
def search(
|
|
self,
|
|
query: str,
|
|
limit: int = 50,
|
|
filters: Optional[Dict[str, Any]] = None,
|
|
**kwargs: Any,
|
|
) -> List[SearchResult]:
|
|
_ = kwargs
|
|
active_filters = dict(filters or {})
|
|
start_path = self._normalize_remote_path(active_filters.get("path") or self._base_path, default=self._base_path)
|
|
search_depth = max(0, _coerce_int(active_filters.get("depth"), self._search_depth))
|
|
type_filter = str(active_filters.get("type") or "any").strip().lower()
|
|
needle = str(query or "").strip()
|
|
max_results = max(0, int(limit or 0))
|
|
if max_results <= 0:
|
|
return []
|
|
|
|
ftp = self._connect()
|
|
try:
|
|
return self._search_directory(
|
|
ftp,
|
|
start_path,
|
|
needle=needle,
|
|
limit=max_results,
|
|
search_depth=search_depth,
|
|
type_filter=type_filter,
|
|
)
|
|
finally:
|
|
self._close(ftp)
|
|
|
|
def selector(
|
|
self,
|
|
selected_items: List[Any],
|
|
*,
|
|
ctx: Any,
|
|
stage_is_last: bool = True,
|
|
**_kwargs: Any,
|
|
) -> bool:
|
|
if not stage_is_last:
|
|
return False
|
|
|
|
target_path = ""
|
|
target_title = ""
|
|
for item in selected_items or []:
|
|
metadata = self._item_metadata(item)
|
|
if not metadata.get("is_dir"):
|
|
continue
|
|
target_path = self._normalize_remote_path(metadata.get("ftp_path") or metadata.get("selection_path"), default=self._base_path)
|
|
target_title = str(metadata.get("title") or metadata.get("name") or "").strip()
|
|
if target_path:
|
|
break
|
|
|
|
if not target_path:
|
|
return False
|
|
|
|
ftp = self._connect()
|
|
try:
|
|
rows = self._search_directory(
|
|
ftp,
|
|
target_path,
|
|
needle="*",
|
|
limit=500,
|
|
search_depth=0,
|
|
type_filter="any",
|
|
)
|
|
finally:
|
|
self._close(ftp)
|
|
|
|
try:
|
|
from SYS.result_table import Table
|
|
from SYS.rich_display import stdout_console
|
|
except Exception:
|
|
return True
|
|
|
|
title = target_title or target_path
|
|
table = Table(f"FTP: {title}")._perseverance(True)
|
|
table.set_table("ftp")
|
|
try:
|
|
table.set_table_metadata({
|
|
"provider": "ftp",
|
|
"host": self._host,
|
|
"path": target_path,
|
|
"view": "directory",
|
|
})
|
|
except Exception:
|
|
pass
|
|
table.set_source_command("search-file", ["-plugin", "ftp", f"path:{target_path}", "*"])
|
|
|
|
payloads: List[Dict[str, Any]] = []
|
|
for row in rows:
|
|
table.add_result(row)
|
|
payloads.append(row.to_dict())
|
|
|
|
try:
|
|
ctx.set_last_result_table(table, payloads, subject={"plugin": "ftp", "path": target_path})
|
|
ctx.set_current_stage_table(table)
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
stdout_console().print()
|
|
stdout_console().print(table)
|
|
except Exception:
|
|
pass
|
|
|
|
return True
|
|
|
|
def download(self, result: SearchResult, output_dir: Path) -> Optional[Path]:
|
|
metadata = getattr(result, "full_metadata", None)
|
|
if isinstance(metadata, dict) and metadata.get("is_dir"):
|
|
return None
|
|
target = str(getattr(result, "path", "") or "").strip()
|
|
if not target:
|
|
return None
|
|
return self.download_url(target, output_dir, title=getattr(result, "title", None))
|
|
|
|
def download_url(self, url: str, output_dir: Path, **kwargs: Any) -> Optional[Path]:
|
|
settings = self._connection_settings_for_url(url)
|
|
remote_path = settings["path"]
|
|
if not remote_path or remote_path == "/":
|
|
return None
|
|
|
|
filename_hint = str(kwargs.get("title") or "").strip()
|
|
parsed_name = posixpath.basename(remote_path.rstrip("/"))
|
|
filename = _safe_filename(filename_hint or unquote(parsed_name) or "download")
|
|
|
|
destination_dir = Path(output_dir)
|
|
destination_dir.mkdir(parents=True, exist_ok=True)
|
|
destination = _unique_path(destination_dir / filename)
|
|
|
|
ftp = self._connect(
|
|
host=settings["host"],
|
|
port=settings["port"],
|
|
username=settings["username"],
|
|
password=settings["password"],
|
|
tls=settings["tls"],
|
|
)
|
|
try:
|
|
with destination.open("wb") as handle:
|
|
ftp.retrbinary(f"RETR {remote_path}", handle.write)
|
|
return destination
|
|
except Exception:
|
|
try:
|
|
destination.unlink(missing_ok=True)
|
|
except Exception:
|
|
pass
|
|
return None
|
|
finally:
|
|
self._close(ftp)
|
|
|
|
def resolve_pipe_result_download(
|
|
self,
|
|
result: Any,
|
|
pipe_obj: Any,
|
|
) -> Tuple[Optional[Path], Optional[str], Optional[Path]]:
|
|
metadata = self._item_metadata(result, pipe_obj=pipe_obj)
|
|
if metadata.get("is_dir"):
|
|
return None, None, None
|
|
|
|
download_url = str(
|
|
metadata.get("selection_url")
|
|
or metadata.get("ftp_url")
|
|
or metadata.get("path")
|
|
or ""
|
|
).strip()
|
|
if not download_url.startswith(("ftp://", "ftps://")):
|
|
return None, None, None
|
|
|
|
temp_dir = Path(tempfile.mkdtemp(prefix="ftp-add-file-"))
|
|
downloaded = self.download_url(download_url, temp_dir, title=metadata.get("title"))
|
|
if downloaded is None:
|
|
try:
|
|
temp_dir.rmdir()
|
|
except Exception:
|
|
pass
|
|
return None, None, None
|
|
|
|
try:
|
|
if pipe_obj is not None:
|
|
pipe_obj.is_temp = True
|
|
except Exception:
|
|
pass
|
|
return downloaded, None, temp_dir
|
|
|
|
def upload(self, file_path: str, **kwargs: Any) -> str:
|
|
local_path = Path(str(file_path or "")).expanduser()
|
|
if not local_path.exists() or not local_path.is_file():
|
|
raise FileNotFoundError(f"File not found: {local_path}")
|
|
|
|
remote_dir = self._normalize_remote_path(kwargs.get("remote_path") or kwargs.get("path") or self._base_path, default=self._base_path)
|
|
remote_name = posixpath.basename(str(kwargs.get("remote_name") or local_path.name).replace("\\", "/")) or local_path.name
|
|
remote_path = self._join_remote_path(remote_dir, remote_name)
|
|
|
|
ftp = self._connect()
|
|
try:
|
|
self._ensure_directory(ftp, remote_dir)
|
|
with local_path.open("rb") as handle:
|
|
ftp.storbinary(f"STOR {remote_path}", handle)
|
|
finally:
|
|
self._close(ftp)
|
|
|
|
return self._build_url(remote_path)
|
|
|
|
def _connect(
|
|
self,
|
|
*,
|
|
host: Optional[str] = None,
|
|
port: Optional[int] = None,
|
|
username: Optional[str] = None,
|
|
password: Optional[str] = None,
|
|
tls: Optional[bool] = None,
|
|
) -> ftplib.FTP:
|
|
use_tls = self._tls if tls is None else bool(tls)
|
|
ftp: ftplib.FTP = ftplib.FTP_TLS() if use_tls else ftplib.FTP()
|
|
ftp.connect(host or self._host, int(port or self._port), timeout=self._timeout)
|
|
ftp.login(username or self._username, password or self._password)
|
|
try:
|
|
ftp.set_pasv(self._passive)
|
|
except Exception:
|
|
pass
|
|
if use_tls and isinstance(ftp, ftplib.FTP_TLS):
|
|
ftp.prot_p()
|
|
return ftp
|
|
|
|
def _close(self, ftp: Optional[ftplib.FTP]) -> None:
|
|
if ftp is None:
|
|
return
|
|
try:
|
|
ftp.quit()
|
|
except Exception:
|
|
try:
|
|
ftp.close()
|
|
except Exception:
|
|
pass
|
|
|
|
def _normalize_remote_path(self, value: Any, *, default: str) -> str:
|
|
text = str(value or "").strip().replace("\\", "/")
|
|
if not text:
|
|
text = default
|
|
elif text.startswith(("ftp://", "ftps://")):
|
|
try:
|
|
text = unquote(urlparse(text).path or "/")
|
|
except Exception:
|
|
text = default
|
|
elif not text.startswith("/"):
|
|
text = posixpath.join(default, text)
|
|
|
|
normalized = posixpath.normpath(text)
|
|
normalized = "/" + normalized.lstrip("/")
|
|
return normalized or "/"
|
|
|
|
def _join_remote_path(self, parent: Any, child: Any) -> str:
|
|
left = self._normalize_remote_path(parent, default=self._base_path)
|
|
right = str(child or "").strip().replace("\\", "/")
|
|
if not right:
|
|
return left
|
|
return self._normalize_remote_path(posixpath.join(left, right), default="/")
|
|
|
|
def _build_url(
|
|
self,
|
|
remote_path: Any,
|
|
*,
|
|
host: Optional[str] = None,
|
|
port: Optional[int] = None,
|
|
tls: Optional[bool] = None,
|
|
) -> str:
|
|
path_text = self._normalize_remote_path(remote_path, default="/")
|
|
scheme = "ftps" if (self._tls if tls is None else bool(tls)) else "ftp"
|
|
host_text = str(host or self._host).strip()
|
|
port_value = int(port or self._port)
|
|
port_suffix = f":{port_value}" if port_value and port_value != 21 else ""
|
|
return f"{scheme}://{host_text}{port_suffix}{quote(path_text, safe='/-._~!$&\'()*+,;=:@')}"
|
|
|
|
def _connection_settings_for_url(self, url: str) -> Dict[str, Any]:
|
|
parsed = urlparse(str(url or "").strip())
|
|
scheme = (parsed.scheme or "ftp").strip().lower()
|
|
host = parsed.hostname or self._host
|
|
port = parsed.port or self._port
|
|
username = parsed.username or self._username
|
|
password = parsed.password or self._password
|
|
path_text = self._normalize_remote_path(unquote(parsed.path or "/"), default="/")
|
|
return {
|
|
"tls": scheme == "ftps",
|
|
"host": host,
|
|
"port": port,
|
|
"username": username,
|
|
"password": password,
|
|
"path": path_text,
|
|
}
|
|
|
|
def _search_directory(
|
|
self,
|
|
ftp: ftplib.FTP,
|
|
start_path: str,
|
|
*,
|
|
needle: str,
|
|
limit: int,
|
|
search_depth: int,
|
|
type_filter: str,
|
|
) -> List[SearchResult]:
|
|
results: List[SearchResult] = []
|
|
visited: set[str] = set()
|
|
|
|
def walk(current_path: str, depth_left: int) -> None:
|
|
normalized = self._normalize_remote_path(current_path, default=self._base_path)
|
|
if normalized in visited or len(results) >= limit:
|
|
return
|
|
visited.add(normalized)
|
|
|
|
for entry in self._list_directory(ftp, normalized):
|
|
if len(results) >= limit:
|
|
return
|
|
if self._matches_entry(entry, needle=needle, type_filter=type_filter):
|
|
results.append(self._build_result(entry))
|
|
if entry.get("is_dir") and depth_left > 0:
|
|
walk(str(entry.get("ftp_path") or normalized), depth_left - 1)
|
|
|
|
walk(start_path, max(0, search_depth))
|
|
return results
|
|
|
|
def _matches_entry(self, entry: Dict[str, Any], *, needle: str, type_filter: str) -> bool:
|
|
is_dir = bool(entry.get("is_dir"))
|
|
if type_filter in {"dir", "dirs", "folder", "folders"} and not is_dir:
|
|
return False
|
|
if type_filter in {"file", "files"} and is_dir:
|
|
return False
|
|
|
|
text = str(needle or "").strip().lower()
|
|
if not text or text in {"*", "all", "list"}:
|
|
return True
|
|
|
|
haystacks = [
|
|
str(entry.get("name") or "").lower(),
|
|
str(entry.get("ftp_path") or "").lower(),
|
|
]
|
|
for token in [part for part in text.split() if part]:
|
|
if any(ch in token for ch in "*?[]"):
|
|
if not any(fnmatch.fnmatch(haystack, token) for haystack in haystacks):
|
|
return False
|
|
elif not any(token in haystack for haystack in haystacks):
|
|
return False
|
|
return True
|
|
|
|
def _build_result(self, entry: Dict[str, Any]) -> SearchResult:
|
|
ftp_path = str(entry.get("ftp_path") or "/")
|
|
ftp_url = self._build_url(ftp_path)
|
|
is_dir = bool(entry.get("is_dir"))
|
|
size_value = entry.get("size")
|
|
modified = str(entry.get("modified") or "")
|
|
parent = posixpath.dirname(ftp_path.rstrip("/")) or "/"
|
|
metadata = {
|
|
"provider": "ftp",
|
|
"host": self._host,
|
|
"ftp_path": ftp_path,
|
|
"ftp_url": ftp_url,
|
|
"selection_url": ftp_url,
|
|
"is_dir": is_dir,
|
|
"name": str(entry.get("name") or "").strip(),
|
|
}
|
|
if size_value is not None:
|
|
metadata["size"] = size_value
|
|
if modified:
|
|
metadata["modified"] = modified
|
|
|
|
return SearchResult(
|
|
table="ftp",
|
|
title=str(entry.get("name") or ftp_path),
|
|
path=ftp_url,
|
|
detail=parent,
|
|
annotations=["folder" if is_dir else "file"],
|
|
media_kind="folder" if is_dir else "file",
|
|
size_bytes=int(size_value) if isinstance(size_value, int) else None,
|
|
tag={"ftp", "folder" if is_dir else "file"},
|
|
columns=[
|
|
("Name", str(entry.get("name") or "")),
|
|
("Type", "dir" if is_dir else "file"),
|
|
("Directory", parent),
|
|
("Size", "" if size_value is None else str(size_value)),
|
|
("Modified", modified),
|
|
],
|
|
selection_args=None if is_dir else ["-url", ftp_url],
|
|
selection_action=None if is_dir else ["download-file", "-plugin", "ftp", "-url", ftp_url],
|
|
full_metadata=metadata,
|
|
)
|
|
|
|
def _list_directory(self, ftp: ftplib.FTP, remote_path: str) -> List[Dict[str, Any]]:
|
|
normalized = self._normalize_remote_path(remote_path, default=self._base_path)
|
|
try:
|
|
entries: List[Dict[str, Any]] = []
|
|
for name, facts in ftp.mlsd(normalized):
|
|
name_text = str(name or "").strip()
|
|
if not name_text or name_text in {".", ".."}:
|
|
continue
|
|
entry_type = str((facts or {}).get("type") or "").strip().lower()
|
|
if entry_type in {"cdir", "pdir"}:
|
|
continue
|
|
size_value = None
|
|
raw_size = (facts or {}).get("size")
|
|
if raw_size not in (None, ""):
|
|
try:
|
|
size_value = int(raw_size)
|
|
except Exception:
|
|
size_value = None
|
|
entries.append(
|
|
{
|
|
"name": name_text,
|
|
"ftp_path": self._join_remote_path(normalized, name_text),
|
|
"is_dir": entry_type == "dir",
|
|
"size": size_value,
|
|
"modified": _format_timestamp((facts or {}).get("modify")),
|
|
}
|
|
)
|
|
return entries
|
|
except Exception:
|
|
return self._list_directory_fallback(ftp, normalized)
|
|
|
|
def _list_directory_fallback(self, ftp: ftplib.FTP, remote_path: str) -> List[Dict[str, Any]]:
|
|
try:
|
|
listed = ftp.nlst(remote_path)
|
|
except Exception:
|
|
return []
|
|
|
|
entries: List[Dict[str, Any]] = []
|
|
seen: set[str] = set()
|
|
for raw_entry in listed:
|
|
entry_text = str(raw_entry or "").strip()
|
|
if not entry_text:
|
|
continue
|
|
entry_path = entry_text if entry_text.startswith("/") else self._join_remote_path(remote_path, entry_text)
|
|
name_text = posixpath.basename(entry_path.rstrip("/")) or entry_path.rstrip("/")
|
|
if not name_text or name_text in {".", ".."} or name_text in seen:
|
|
continue
|
|
seen.add(name_text)
|
|
is_dir = self._is_directory(ftp, entry_path)
|
|
size_value = None
|
|
if not is_dir:
|
|
try:
|
|
size_raw = ftp.size(entry_path)
|
|
if size_raw is not None:
|
|
size_value = int(size_raw)
|
|
except Exception:
|
|
size_value = None
|
|
entries.append(
|
|
{
|
|
"name": name_text,
|
|
"ftp_path": entry_path,
|
|
"is_dir": is_dir,
|
|
"size": size_value,
|
|
"modified": self._read_modified(ftp, entry_path),
|
|
}
|
|
)
|
|
return entries
|
|
|
|
def _is_directory(self, ftp: ftplib.FTP, remote_path: str) -> bool:
|
|
current = None
|
|
try:
|
|
current = ftp.pwd()
|
|
except Exception:
|
|
current = None
|
|
try:
|
|
ftp.cwd(remote_path)
|
|
return True
|
|
except Exception:
|
|
return False
|
|
finally:
|
|
if current is not None:
|
|
try:
|
|
ftp.cwd(current)
|
|
except Exception:
|
|
pass
|
|
|
|
def _read_modified(self, ftp: ftplib.FTP, remote_path: str) -> str:
|
|
try:
|
|
response = ftp.sendcmd(f"MDTM {remote_path}")
|
|
except Exception:
|
|
return ""
|
|
parts = str(response or "").split()
|
|
if len(parts) >= 2:
|
|
return _format_timestamp(parts[1])
|
|
return ""
|
|
|
|
def _ensure_directory(self, ftp: ftplib.FTP, remote_path: str) -> None:
|
|
normalized = self._normalize_remote_path(remote_path, default=self._base_path)
|
|
if normalized == "/":
|
|
return
|
|
partial = ""
|
|
for segment in [part for part in normalized.split("/") if part]:
|
|
partial = f"{partial}/{segment}"
|
|
if self._is_directory(ftp, partial):
|
|
continue
|
|
try:
|
|
ftp.mkd(partial)
|
|
except Exception:
|
|
if not self._is_directory(ftp, partial):
|
|
raise
|
|
|
|
def _item_metadata(self, item: Any, *, pipe_obj: Any = None) -> Dict[str, Any]:
|
|
metadata: Dict[str, Any] = {}
|
|
for source in (item, pipe_obj):
|
|
if isinstance(source, dict):
|
|
for key in ("title", "path", "url"):
|
|
if source.get(key) is not None and key not in metadata:
|
|
metadata[key] = source.get(key)
|
|
nested = source.get("full_metadata") or source.get("metadata")
|
|
if isinstance(nested, dict):
|
|
metadata.update(nested)
|
|
elif source is not None:
|
|
for attr in ("title", "path", "url"):
|
|
try:
|
|
value = getattr(source, attr, None)
|
|
except Exception:
|
|
value = None
|
|
if value is not None and attr not in metadata:
|
|
metadata[attr] = value
|
|
try:
|
|
nested = getattr(source, "full_metadata", None) or getattr(source, "metadata", None)
|
|
except Exception:
|
|
nested = None
|
|
if isinstance(nested, dict):
|
|
metadata.update(nested)
|
|
|
|
ftp_path = metadata.get("ftp_path") or metadata.get("selection_path")
|
|
if not ftp_path:
|
|
path_value = metadata.get("path") or metadata.get("url") or metadata.get("ftp_url")
|
|
path_text = str(path_value or "").strip()
|
|
if path_text.startswith(("ftp://", "ftps://")):
|
|
ftp_path = self._normalize_remote_path(path_text, default=self._base_path)
|
|
if ftp_path:
|
|
metadata["ftp_path"] = self._normalize_remote_path(ftp_path, default=self._base_path)
|
|
metadata.setdefault("selection_path", metadata["ftp_path"])
|
|
|
|
if metadata.get("ftp_path") and not metadata.get("ftp_url"):
|
|
metadata["ftp_url"] = self._build_url(metadata["ftp_path"])
|
|
if metadata.get("ftp_url") and not metadata.get("selection_url"):
|
|
metadata["selection_url"] = metadata["ftp_url"]
|
|
|
|
is_dir = metadata.get("is_dir")
|
|
if is_dir is None and metadata.get("media_kind"):
|
|
is_dir = str(metadata.get("media_kind") or "").strip().lower() == "folder"
|
|
metadata["is_dir"] = bool(is_dir)
|
|
return metadata |