feat(cli): add crawling and querying commands for TDoc, meetings, and specs (ab237925) · Commits · Jan Reimes / 3gpp-crawler

src/tdoc_crawler/cli/_shared.py

0 → 100644

+82 −0

Original line number	Diff line number	Diff line
		"""Shared utilities for CLI commands."""

		from __future__ import annotations

		from pathlib import Path
		from typing import Any

		from rich.progress import BarColumn, MofNCompleteColumn, Progress, SpinnerColumn, TaskID, TextColumn

		from tdoc_crawler.logging import get_console
		from tdoc_crawler.specs.operations.checkout import clear_checkout_specs
		from tdoc_crawler.tdocs.operations.checkout import clear_checkout_tdocs

		console = get_console()


		def handle_clear_options(
		database: Any,
		checkout_dir: Path,
		clear_tdocs: bool = False,
		clear_specs: bool = False,
		clear_db: bool = False,
		) -> None:
		"""Handle clear options for TDoc and spec data.

		Args:
		database: Database instance (TDocDatabase or MeetingDatabase)
		checkout_dir: Path to checkout directory
		clear_tdocs: Whether to clear TDocs
		clear_specs: Whether to clear specs
		clear_db: Whether to clear all data (only for MeetingDatabase)
		"""
		if clear_db:
		tdocs_count, meetings_count = database.clear_all_data()
		console.print(f"[yellow]Cleared {tdocs_count} TDocs and {meetings_count} meetings from database[/yellow]")
		removed = clear_checkout_tdocs(checkout_dir)
		if removed:
		console.print(f"[yellow]Cleared {removed} checkout entries for TDocs[/yellow]")
		return

		if clear_tdocs:
		deleted_count = database.clear_tdocs()
		console.print(f"[yellow]Cleared {deleted_count} TDocs from database[/yellow]")
		removed = clear_checkout_tdocs(checkout_dir)
		if removed:
		console.print(f"[yellow]Cleared {removed} checkout entries for TDocs[/yellow]")

		if clear_specs:
		spec_counts = database.clear_specs()
		total_specs = sum(spec_counts.values())
		console.print(f"[yellow]Cleared {total_specs} spec rows from database[/yellow]")
		removed_specs = clear_checkout_specs(checkout_dir)
		if removed_specs:
		console.print("[yellow]Cleared checkout entries for specs[/yellow]")


		def create_progress_bar(description: str, total: float = 100) -> tuple[Progress, TaskID]:
		"""Create a standard progress bar for CLI operations.

		Args:
		description: Task description
		total: Initial total (will be updated by callback)

		Returns:
		Tuple of (Progress context manager, task ID)
		"""
		progress = Progress(
		SpinnerColumn(),
		TextColumn("[progress.description]{task.description}"),
		BarColumn(),
		MofNCompleteColumn(),
		console=console,
		)
		task = progress.add_task(description, total=total)
		return progress, task


		__all__ = [
		"console",
		"create_progress_bar",
		"handle_clear_options",
		]

src/tdoc_crawler/cli/app.py

+26 −747

File changed.

Preview size limit exceeded, changes collapsed.

src/tdoc_crawler/cli/crawl.py

0 → 100644

+334 −0

Original line number	Diff line number	Diff line
		"""Crawling commands for TDoc, meeting, and spec metadata."""

		from __future__ import annotations

		import json
		from datetime import datetime

		import typer
		import yaml
		from dotenv import load_dotenv

		from tdoc_crawler.cli._shared import console, create_progress_bar, handle_clear_options
		from tdoc_crawler.cli.args import (
		CacheDirOption,
		CheckoutOption,
		ClearDbOption,
		ClearSpecsOption,
		ClearTDocsOption,
		EolPasswordOption,
		EolUsernameOption,
		HttpCacheOption,
		IncrementalOption,
		LimitMeetingsOption,
		LimitMeetingsPerWgOption,
		LimitTDocsOption,
		LimitWgsOption,
		MaxRetriesOption,
		OutputFormatOption,
		OverallTimeoutOption,
		PromptCredentialsOption,
		ReleaseOption,
		SpecArgument,
		SpecFileOption,
		SubgroupOption,
		TimeoutOption,
		VerbosityOption,
		WorkersOption,
		WorkingGroupOption,
		)
		from tdoc_crawler.cli.printing import print_spec_crawl_table, spec_crawl_to_dict
		from tdoc_crawler.config import CacheManager
		from tdoc_crawler.credentials import set_credentials
		from tdoc_crawler.database import MeetingDatabase, TDocDatabase
		from tdoc_crawler.database.specs import SpecDatabase
		from tdoc_crawler.http_client import create_cached_session
		from tdoc_crawler.logging import DEFAULT_LEVEL as DEFAULT_VERBOSITY
		from tdoc_crawler.logging import set_verbosity
		from tdoc_crawler.meetings.models import MeetingCrawlConfig, MeetingQueryConfig
		from tdoc_crawler.meetings.operations.crawl import MeetingCrawler
		from tdoc_crawler.models.base import HttpCacheConfig, OutputFormat, SortOrder
		from tdoc_crawler.models.crawl_limits import CrawlLimits
		from tdoc_crawler.specs.operations.checkout import build_default_spec_sources, checkout_specs
		from tdoc_crawler.tdocs.models import TDocCrawlConfig, TDocQueryConfig
		from tdoc_crawler.tdocs.operations import TDocCrawler
		from tdoc_crawler.tdocs.operations.checkout import checkout_meeting_tdocs, checkout_tdocs
		from tdoc_crawler.utils.parse import collect_spec_numbers, parse_subgroups, parse_working_groups

		load_dotenv()

		HELP_PANEL = "Crawling Commands"


		def crawl_tdocs(
		working_group: WorkingGroupOption = None,
		subgroup: SubgroupOption = None,
		limit_tdocs: LimitTDocsOption = None,
		limit_meetings: LimitMeetingsOption = None,
		limit_meetings_per_wg: LimitMeetingsPerWgOption = None,
		limit_wgs: LimitWgsOption = None,
		checkout: CheckoutOption = False,
		incremental: IncrementalOption = True,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		workers: WorkersOption = 4,
		timeout: TimeoutOption = 30,
		max_retries: MaxRetriesOption = 3,
		overall_timeout: OverallTimeoutOption = None,
		cache_dir: CacheDirOption = None,
		http_cache_enabled: HttpCacheOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Crawl TDocs from 3GPP FTP directories.

		No credentials needed, crawl-tdocs always resolves meetings first -> parse Excel files that includes metadata.
		"""
		set_verbosity(verbosity)

		manager = CacheManager(cache_dir).register()
		subgroups = parse_subgroups(subgroup)
		working_groups = parse_working_groups(working_group, subgroups)

		limits = CrawlLimits.build(limit_tdocs, limit_meetings, limit_meetings_per_wg, limit_wgs)

		http_cache = HttpCacheConfig.resolve_http_cache_config(
		cache_ttl=None, cache_refresh_on_access=None, max_retries=max_retries, cache_file=manager.http_cache_file
		)

		config = TDocCrawlConfig(
		working_groups=working_groups,
		subgroups=subgroups,
		meeting_ids=None,
		start_date=None,
		end_date=None,
		incremental=incremental,
		force_revalidate=False,
		workers=workers,
		overall_timeout=overall_timeout,
		timeout=timeout,
		limits=limits,
		target_ids=None,
		use_document_list=True,
		allow_parallel_fallback=True,
		use_parallel_crawling=False,
		http_cache=http_cache,
		)

		db_file = manager.db_file

		scope_parts = []
		if subgroups:
		scope_parts.append(f"subgroups: {', '.join(subgroups)}")
		else:
		scope_parts.append(f"working groups: {', '.join(wg.value for wg in working_groups)}")
		console.print(f"[cyan]Crawling TDocs ({', '.join(scope_parts)})[/cyan]")

		with TDocDatabase(db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs)

		crawler = TDocCrawler(database)
		crawl_id = database.log_crawl_start("tdoc", [wg.value for wg in config.working_groups], config.incremental)

		crawl_start_time = datetime.now()

		progress, task = create_progress_bar("[cyan]Crawling TDocs...")

		with progress:

		def update_progress(completed: float, total: float) -> None:
		progress.update(task, completed=completed, total=total)

		result = crawler.crawl(config, progress_callback=update_progress)

		crawl_end_time = datetime.now()
		elapsed_seconds = (crawl_end_time - crawl_start_time).total_seconds()
		throughput = result.processed / elapsed_seconds if elapsed_seconds > 0 else 0

		database.log_crawl_end(
		crawl_id,
		items_added=result.inserted,
		items_updated=result.updated,
		errors_count=len(result.errors),
		)

		if checkout:
		checkout_limit = limit_tdocs if limit_tdocs and limit_tdocs > 0 else None
		query_config = TDocQueryConfig(
		cache_dir=manager.root,
		working_groups=working_groups,
		limit=checkout_limit,
		order=SortOrder.DESC,
		)
		results = database.query_tdocs(query_config)

		with create_cached_session(http_cache_enabled=http_cache_enabled) as session:
		checkout_result = checkout_tdocs(results, checkout_dir, force=False, session=session)

		console.print(f"\n[cyan]Checked out {checkout_result.success_count} TDoc(s)[/cyan]")
		if checkout_result.error_count:
		console.print(f"[red]Failed: {checkout_result.error_count} TDoc(s)[/red]")
		if checkout_result.errors:
		for error in checkout_result.errors[:5]:
		console.print(f" - {error}")

		console.print(f"[green]Processed {result.processed} TDocs ({throughput:.1f} TDocs/sec)[/green]")
		console.print(f"[green]Inserted {result.inserted}, updated {result.updated}[/green]")
		if result.errors:
		console.print(f"[yellow]{len(result.errors)} issues detected[/yellow]")
		for error in result.errors[:5]:
		console.print(f" - {error}")


		def crawl_meetings(
		working_group: WorkingGroupOption = None,
		subgroup: SubgroupOption = None,
		limit_meetings: LimitMeetingsOption = None,
		limit_meetings_per_wg: LimitMeetingsPerWgOption = None,
		limit_wgs: LimitWgsOption = None,
		checkout: CheckoutOption = False,
		incremental: IncrementalOption = True,
		clear_db: ClearDbOption = False,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		timeout: TimeoutOption = 30,
		max_retries: MaxRetriesOption = 3,
		eol_username: EolUsernameOption = None,
		eol_password: EolPasswordOption = None,
		prompt_credentials: PromptCredentialsOption = None,
		cache_dir: CacheDirOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Crawl meeting metadata from 3GPP portal."""
		set_verbosity(verbosity)
		set_credentials(eol_username, eol_password, prompt=prompt_credentials)

		manager = CacheManager(cache_dir).register()

		subgroups = parse_subgroups(subgroup)
		working_groups = parse_working_groups(working_group, subgroups)
		limits = CrawlLimits.build(None, limit_meetings, limit_meetings_per_wg, limit_wgs)

		config = MeetingCrawlConfig(
		working_groups=working_groups,
		subgroups=subgroups,
		incremental=incremental,
		max_retries=max_retries,
		timeout=timeout,
		limits=limits,
		)

		db_file = manager.db_file

		scope_parts = []
		if subgroups:
		scope_parts.append(f"subgroups: {', '.join(subgroups)}")
		else:
		scope_parts.append(f"working groups: {', '.join(wg.value for wg in working_groups)}")
		console.print(f"[cyan]Crawling meetings ({', '.join(scope_parts)})[/cyan]")

		with MeetingDatabase(db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs, clear_db=clear_db)

		with MeetingDatabase(db_file) as database:
		crawl_id = database.log_crawl_start("meeting", [wg.value for wg in config.working_groups], config.incremental)

		crawler = MeetingCrawler(database)

		progress, task = create_progress_bar("[cyan]Crawling meetings...")

		with progress:

		def update_progress(completed: float, total: float) -> None:
		progress.update(task, completed=completed, total=total)

		result = crawler.crawl(config, progress_callback=update_progress)

		database.log_crawl_end(
		crawl_id,
		items_added=result.inserted,
		items_updated=result.updated,
		errors_count=len(result.errors),
		)

		console.print(f"[green]Processed {result.processed} meetings[/green]")
		console.print(f"[green]Inserted {result.inserted}, updated {result.updated}[/green]")
		if result.errors:
		console.print(f"[yellow]{len(result.errors)} issues detected[/yellow]")
		for error in result.errors[:5]:
		console.print(f" - {error}")

		if checkout:
		query_config = MeetingQueryConfig(
		working_groups=working_groups,
		subgroups=subgroups,
		limit=limit_meetings if limit_meetings and limit_meetings > 0 else None,
		order=SortOrder.DESC,
		include_without_files=False,
		)
		with MeetingDatabase(db_file) as database:
		meetings = database.query_meetings(query_config)

		with create_cached_session() as session:
		checkout_meeting_tdocs(meetings, manager.checkout_dir, manager.http_cache_file, session=session)


		def crawl_specs(
		spec_numbers: SpecArgument = None,
		release: ReleaseOption = "latest",
		checkout: CheckoutOption = False,
		output_format: OutputFormatOption = OutputFormat.TABLE.value,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		spec_file: SpecFileOption = None,
		cache_dir: CacheDirOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Crawl spec metadata from configured sources."""
		set_verbosity(verbosity)
		manager = CacheManager(cache_dir).register()
		spec_numbers = spec_numbers or []

		specs = collect_spec_numbers(spec_numbers, spec_file)
		try:
		output = OutputFormat(output_format.lower())
		except ValueError as exc:
		console.print("[red]Invalid output format; use table, json, or yaml")
		raise typer.Exit(code=2) from exc

		sources = build_default_spec_sources()

		with SpecDatabase(manager.db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs)

		results = database.crawl_specs(specs, release, sources)

		if not results:
		console.print("[yellow]No specs crawled[/yellow]")
		return

		if checkout:
		with SpecDatabase(manager.db_file) as database:
		checkout_specs(
		[result.spec_number for result in results],
		manager.checkout_dir,
		database,
		release=release,
		)

		if output is OutputFormat.JSON:
		console.print(json.dumps([spec_crawl_to_dict(result) for result in results], indent=2))
		elif output is OutputFormat.YAML:
		console.print(yaml.dump([spec_crawl_to_dict(result) for result in results], sort_keys=False))
		else:
		print_spec_crawl_table(results)


		__all__ = [
		"HELP_PANEL",
		"crawl_meetings",
		"crawl_specs",
		"crawl_tdocs",
		]

src/tdoc_crawler/cli/query.py

0 → 100644

+269 −0

Original line number	Diff line number	Diff line
		"""Query commands for TDoc, meeting, and spec metadata."""

		from __future__ import annotations

		import json
		from datetime import datetime

		import typer
		import yaml
		from dotenv import load_dotenv

		from tdoc_crawler.cli._shared import console, handle_clear_options
		from tdoc_crawler.cli.args import (
		CacheDirOption,
		CheckoutOption,
		ClearSpecsOption,
		ClearTDocsOption,
		EndDateOption,
		IncludeWithoutFilesOption,
		LimitOption,
		NoFetchOption,
		OrderOption,
		OutputFormatOption,
		SpecArgument,
		SpecFileOption,
		StartDateOption,
		StatusOption,
		SubgroupOption,
		TDocIdsArgument,
		TitleOption,
		VerbosityOption,
		WorkingGroupOption,
		)
		from tdoc_crawler.cli.printing import (
		meeting_to_dict,
		print_meeting_table,
		print_spec_table,
		print_tdoc_table,
		spec_query_to_dict,
		tdoc_to_dict,
		)
		from tdoc_crawler.config import CacheManager
		from tdoc_crawler.database import MeetingDatabase, TDocDatabase
		from tdoc_crawler.database.specs import SpecDatabase
		from tdoc_crawler.http_client import create_cached_session
		from tdoc_crawler.logging import DEFAULT_LEVEL as DEFAULT_VERBOSITY
		from tdoc_crawler.logging import set_verbosity
		from tdoc_crawler.meetings.models import MeetingQueryConfig
		from tdoc_crawler.models.base import OutputFormat, SortOrder
		from tdoc_crawler.specs.models import SpecQueryFilters
		from tdoc_crawler.specs.operations.checkout import checkout_specs
		from tdoc_crawler.tdocs.models import TDocQueryConfig
		from tdoc_crawler.tdocs.operations.checkout import checkout_meeting_tdocs, checkout_tdocs
		from tdoc_crawler.tdocs.operations.fetch import fetch_missing_tdocs
		from tdoc_crawler.utils.parse import collect_spec_numbers, parse_subgroups, parse_working_groups

		load_dotenv()

		HELP_PANEL = "Query Commands"


		def query_tdocs(
		tdoc_ids: TDocIdsArgument = None,
		working_group: WorkingGroupOption = None,
		start_date: StartDateOption = None,
		end_date: EndDateOption = None,
		limit: LimitOption = None,
		order: OrderOption = SortOrder.DESC.value,
		output_format: OutputFormatOption = OutputFormat.TABLE.value,
		checkout: CheckoutOption = False,
		no_fetch: NoFetchOption = False,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		cache_dir: CacheDirOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Query TDoc metadata from database."""
		set_verbosity(verbosity)
		manager = CacheManager(cache_dir).register()

		working_groups = parse_working_groups(working_group)
		try:
		start = datetime.fromisoformat(start_date) if start_date else None
		except ValueError as exc:
		console.print("[red]Invalid start date format; use ISO-8601")
		raise typer.Exit(code=2) from exc
		try:
		end = datetime.fromisoformat(end_date) if end_date else None
		except ValueError as exc:
		console.print("[red]Invalid end date format; use ISO-8601")
		raise typer.Exit(code=2) from exc

		try:
		sort_order = SortOrder(order.lower())
		except ValueError as exc:
		console.print("[red]Invalid order value; use asc or desc")
		raise typer.Exit(code=2) from exc

		config = TDocQueryConfig(
		cache_dir=manager.root,
		output_format=output_format,
		tdoc_ids=tdoc_ids,
		working_groups=working_groups,
		start_date=start,
		end_date=end,
		limit=limit,
		order=sort_order,
		)

		db_file = manager.db_file
		with TDocDatabase(db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs)

		results = database.query_tdocs(config)
		if not no_fetch:
		with create_cached_session() as session:
		result = fetch_missing_tdocs(
		database,
		config,
		results,
		session=session,
		cache_manager_name=manager.name,
		)
		if result.fetch_result and result.fetch_result.errors:
		console.print(f"[yellow]{len(result.fetch_result.errors)} issues detected during targeted crawl[/yellow]")
		for error in result.fetch_result.errors[:3]:
		console.print(f" - {error}")
		results = result.refreshed

		if not results:
		console.print("[yellow]No TDocs found[/yellow]")
		return

		if checkout:
		with create_cached_session() as session:
		checkout_tdocs(results, manager.checkout_dir, force=False, session=session)

		if config.output_format is OutputFormat.JSON:
		console.print(json.dumps([tdoc_to_dict(result) for result in results], indent=2))
		elif config.output_format is OutputFormat.YAML:
		console.print(yaml.dump([tdoc_to_dict(result) for result in results], sort_keys=False))
		else:
		print_tdoc_table(results)


		def query_meetings(
		working_group: WorkingGroupOption = None,
		subgroup: SubgroupOption = None,
		limit: LimitOption = None,
		order: OrderOption = SortOrder.DESC.value,
		output_format: OutputFormatOption = OutputFormat.TABLE.value,
		checkout: CheckoutOption = False,
		include_without_files: IncludeWithoutFilesOption = False,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		cache_dir: CacheDirOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Query meeting metadata from database."""
		set_verbosity(verbosity)
		manager = CacheManager(cache_dir).register()
		working_groups = parse_working_groups(working_group)
		subgroups = parse_subgroups(subgroup)
		try:
		sort_order_meetings = SortOrder(order.lower())
		except ValueError as exc:
		console.print("[red]Invalid order value; use asc or desc")
		raise typer.Exit(code=2) from exc

		config = MeetingQueryConfig(
		working_groups=working_groups,
		subgroups=subgroups,
		limit=limit,
		order=sort_order_meetings,
		include_without_files=include_without_files,
		)

		db_file = manager.db_file
		with MeetingDatabase(db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs)

		meetings = database.query_meetings(config)

		if not meetings:
		console.print("[yellow]No meetings found[/yellow]")
		return

		if checkout:
		with create_cached_session() as session:
		checkout_meeting_tdocs(meetings, manager.checkout_dir, manager.http_cache_file, session=session)

		try:
		output = OutputFormat(output_format.lower())
		except ValueError as exc:
		console.print("[red]Invalid output format; use table, json, or yaml")
		raise typer.Exit(code=2) from exc
		if output is OutputFormat.JSON:
		console.print(json.dumps([meeting_to_dict(meeting) for meeting in meetings], indent=2))
		elif output is OutputFormat.YAML:
		console.print(yaml.dump([meeting_to_dict(meeting) for meeting in meetings], sort_keys=False))
		else:
		print_meeting_table(meetings)


		def query_specs(
		spec_numbers: SpecArgument = None,
		title: TitleOption = None,
		working_group: WorkingGroupOption = None,
		status: StatusOption = None,
		output_format: OutputFormatOption = OutputFormat.TABLE.value,
		checkout: CheckoutOption = False,
		clear_tdocs: ClearTDocsOption = False,
		clear_specs: ClearSpecsOption = False,
		spec_file: SpecFileOption = None,
		cache_dir: CacheDirOption = None,
		verbosity: VerbosityOption = str(DEFAULT_VERBOSITY),
		) -> None:
		"""Query spec metadata from database."""
		set_verbosity(verbosity)
		manager = CacheManager(cache_dir).register()
		specs = collect_spec_numbers(spec_numbers, spec_file)
		working_groups = parse_working_groups(working_group)
		wg_filter = working_groups[0].value if working_groups else None

		filters = SpecQueryFilters(
		spec_numbers=specs,
		title=title,
		working_group=wg_filter,
		status=status,
		)

		try:
		output = OutputFormat(output_format.lower())
		except ValueError as exc:
		console.print("[red]Invalid output format; use table, json, or yaml")
		raise typer.Exit(code=2) from exc

		db_file = manager.db_file
		with SpecDatabase(db_file) as database:
		checkout_dir = manager.checkout_dir
		handle_clear_options(database, checkout_dir, clear_tdocs=clear_tdocs, clear_specs=clear_specs)

		results = database.query_specs(filters)

		if not results:
		console.print("[yellow]No specs found[/yellow]")
		return

		if checkout:
		spec_list = [result.spec_number for result in results]
		with SpecDatabase(db_file) as database:
		checkout_specs(spec_list, manager.checkout_dir, database, release="latest")

		if output is OutputFormat.JSON:
		console.print(json.dumps([spec_query_to_dict(result) for result in results], indent=2))
		elif output is OutputFormat.YAML:
		console.print(yaml.dump([spec_query_to_dict(result) for result in results], sort_keys=False))
		else:
		print_spec_table(results)


		__all__ = [
		"HELP_PANEL",
		"query_meetings",
		"query_specs",
		"query_tdocs",
		]

src/tdoc_crawler/cli/specs.py

0 → 100644

+96 −0

File added.

Preview size limit exceeded, changes collapsed.