tibiawikisql 7.0.3__tar.gz → 8.0.1__tar.gz

{tibiawikisql-7.0.3/tibiawikisql.egg-info → tibiawikisql-8.0.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: tibiawikisql
-Version: 7.0.3
+Version: 8.0.1
 Summary: Python script that generates a SQLite database from TibiaWiki articles
-Author-email: Allan Galarza <allan.galarza@gmail.com>
-Maintainer-email: Allan Galarza <allan.galarza@gmail.com>
+Author-email: Allan Galarza <contact@galarzaa.com>
+Maintainer-email: Allan Galarza <contact@galarzaa.com>
 License: Apache 2.0
 Project-URL: Homepage, https://tibiawiki-sql.readthedocs.io/
 Project-URL: Documentation, https://tibiawiki-sql.readthedocs.io/

{tibiawikisql-7.0.3 → tibiawikisql-8.0.1}/pyproject.toml

@@ -12,10 +12,10 @@ include = [
 name = "tibiawikisql"
 dynamic = ["version", "dependencies", "optional-dependencies"]
 authors = [
-    { name = "Allan Galarza", email = "allan.galarza@gmail.com" }
+    { name = "Allan Galarza", email = "contact@galarzaa.com" }
 ]
 maintainers = [
-    { name = "Allan Galarza", email = "allan.galarza@gmail.com" }
+    { name = "Allan Galarza", email = "contact@galarzaa.com" }
 ]
 license = { text = 'Apache 2.0' }
 description = "Python script that generates a SQLite database from TibiaWiki articles"

tibiawikisql-8.0.1/tests/test_generation.py

@@ -0,0 +1,301 @@
+import datetime
+import sqlite3
+import unittest
+from unittest.mock import Mock, patch
+
+from click.testing import CliRunner
+
+from tests import load_resource
+from tibiawikisql import __main__ as cli_module
+from tibiawikisql import generation as generation_module
+from tibiawikisql.api import Article
+from tibiawikisql.generation import WEAPON_PROFICIENCY_NAME_ARTICLE, WEAPON_PROFICIENCY_TABLES_ARTICLE
+from tibiawikisql.schema import ItemProficiencyPerkTable, ItemTable
+from tibiawikisql.tasks.item_proficiency_perks import generate_item_proficiency_perks
+from tibiawikisql.tasks.loot_statistics import generate_loot_statistics
+
+
+class TestGeneration(unittest.TestCase):
+    def setUp(self):
+        self.conn = sqlite3.connect(":memory:")
+        self.conn.executescript(ItemTable.get_create_table_statement())
+        self.conn.executescript(ItemProficiencyPerkTable.get_create_table_statement())
+        timestamp = datetime.datetime.fromisoformat("2024-01-01T00:00:00+00:00")
+        ItemTable.insert(self.conn, article_id=1, title="Amber Axe", timestamp=timestamp)
+        ItemTable.insert(self.conn, article_id=2, title="Amber Cudgel", timestamp=timestamp)
+
+    def tearDown(self):
+        self.conn.close()
+
+    @staticmethod
+    def build_article(title: str, content: str) -> Article:
+        return Article(
+            article_id=9999,
+            title=title,
+            timestamp=datetime.datetime.fromisoformat("2024-01-01T00:00:00+00:00"),
+            content=content,
+        )
+
+    def test_generate_item_proficiency_perks(self):
+        mapping_article = self.build_article(
+            WEAPON_PROFICIENCY_NAME_ARTICLE,
+            load_resource("content_weapon_proficiency_name.txt"),
+        )
+        tables_article = self.build_article(
+            WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            load_resource("content_weapon_proficiency_tables.txt"),
+        )
+        data_store = {"items_map": {"amber axe": 1, "amber cudgel": 2}}
+
+        wiki_client = Mock()
+        wiki_client.get_article.side_effect = [mapping_article, tables_article]
+        mock_echo = Mock()
+        generate_item_proficiency_perks(
+            self.conn,
+            data_store,
+            wiki_client=wiki_client,
+            mapping_article_title=WEAPON_PROFICIENCY_NAME_ARTICLE,
+            tables_article_title=WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            timed=generation_module.timed,
+            echo=mock_echo,
+        )
+
+        rows = self.conn.execute(
+            "SELECT item_id, proficiency_level, skill_image, icon, effect "
+            "FROM item_proficiency_perk ORDER BY rowid",
+        ).fetchall()
+        self.assertEqual(4, len(rows))
+        self.assertEqual(
+            [
+                (1, 1, "Axe Skill Bonus", None, "+1 Axe Fighting"),
+                (1, 2, "Auto-Attack Critical Extra Damage", None, "+10% critical extra damage for auto-attacks"),
+                (
+                    1,
+                    2,
+                    "Axe Extra Damage Auto-Attack",
+                    "Special Icon",
+                    "+5% of your Axe Fighting as extra damage for auto-attacks",
+                ),
+                (2, 1, "Club Skill Bonus", None, "+1 Club Fighting"),
+            ],
+            [tuple(row) for row in rows],
+        )
+        messages = " ".join(call.args[0] for call in mock_echo.call_args_list if call.args)
+        self.assertIn("Parsed weapon proficiency perks", messages)
+
+    def test_generate_item_proficiency_perks_warn_and_continue(self):
+        mapping_article = self.build_article(
+            WEAPON_PROFICIENCY_NAME_ARTICLE,
+            """{{#switch:{{{1|}}}
+| Amber Axe = Sanguine 1H Axe
+| Amber Cudgel = Missing Section
+| Unknown Item = Sanguine 1H Club
+|#default =
+}}""",
+        )
+        tables_article = self.build_article(
+            WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            load_resource("content_weapon_proficiency_tables.txt"),
+        )
+        data_store = {"items_map": {"amber axe": 1, "amber cudgel": 2}}
+
+        wiki_client = Mock()
+        wiki_client.get_article.side_effect = [mapping_article, tables_article]
+        mock_echo = Mock()
+        generate_item_proficiency_perks(
+            self.conn,
+            data_store,
+            wiki_client=wiki_client,
+            mapping_article_title=WEAPON_PROFICIENCY_NAME_ARTICLE,
+            tables_article_title=WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            timed=generation_module.timed,
+            echo=mock_echo,
+        )
+
+        rows = self.conn.execute(
+            "SELECT item_id, proficiency_level, skill_image, icon, effect FROM item_proficiency_perk",
+        ).fetchall()
+        self.assertEqual(3, len(rows))
+        messages = " ".join(call.args[0] for call in mock_echo.call_args_list if call.args)
+        self.assertIn("Could not map 1 item names to IDs", messages)
+        self.assertIn("Could not find 1 proficiency sections", messages)
+        self.assertIn("Skipped 1 malformed weapon proficiency perks", messages)
+
+    def test_generate_item_proficiency_perks_no_title_fallback(self):
+        mapping_article = self.build_article(
+            WEAPON_PROFICIENCY_NAME_ARTICLE,
+            load_resource("content_weapon_proficiency_name.txt"),
+        )
+        data_store = {"items_map": {"amber axe": 1, "amber cudgel": 2}}
+
+        def get_article_side_effect(title: str) -> Article | None:
+            if title == WEAPON_PROFICIENCY_NAME_ARTICLE:
+                return mapping_article
+            return None
+
+        wiki_client = Mock()
+        wiki_client.get_article.side_effect = get_article_side_effect
+        mock_echo = Mock()
+        generate_item_proficiency_perks(
+            self.conn,
+            data_store,
+            wiki_client=wiki_client,
+            mapping_article_title=WEAPON_PROFICIENCY_NAME_ARTICLE,
+            tables_article_title=WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            timed=generation_module.timed,
+            echo=mock_echo,
+        )
+
+        rows = self.conn.execute("SELECT COUNT(*) FROM item_proficiency_perk").fetchone()
+        self.assertEqual(0, rows[0])
+        self.assertEqual(
+            [
+                WEAPON_PROFICIENCY_NAME_ARTICLE,
+                WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            ],
+            [call.args[0] for call in wiki_client.get_article.call_args_list],
+        )
+        messages = " ".join(call.args[0] for call in mock_echo.call_args_list if call.args)
+        self.assertIn("Could not fetch weapon proficiency pages", messages)
+        self.assertIn(WEAPON_PROFICIENCY_TABLES_ARTICLE, messages)
+
+    def test_generate_item_proficiency_perks_case_insensitive_section_match(self):
+        timestamp = datetime.datetime.fromisoformat("2024-01-01T00:00:00+00:00")
+        ItemTable.insert(self.conn, article_id=3, title="Stale Bread of Ancientness", timestamp=timestamp)
+
+        mapping_article = self.build_article(
+            WEAPON_PROFICIENCY_NAME_ARTICLE,
+            """{{#switch:{{{1|}}}
+| Stale Bread of Ancientness = Club 1H Stale Bread of Ancientness
+|#default =
+}}""",
+        )
+        tables_article = self.build_article(
+            WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            """===Club 1H Stale Bread Of Ancientness===
+{{Weapon Proficiency Table
+|perk_1 =
+{{Weapon Proficiency Button |skill_image=Club Skill Bonus|icon=|text=+1 Club Fighting}}
+}}""",
+        )
+        data_store = {"items_map": {"stale bread of ancientness": 3}}
+
+        wiki_client = Mock()
+        wiki_client.get_article.side_effect = [mapping_article, tables_article]
+        generate_item_proficiency_perks(
+            self.conn,
+            data_store,
+            wiki_client=wiki_client,
+            mapping_article_title=WEAPON_PROFICIENCY_NAME_ARTICLE,
+            tables_article_title=WEAPON_PROFICIENCY_TABLES_ARTICLE,
+            timed=generation_module.timed,
+            echo=Mock(),
+        )
+
+        rows = self.conn.execute(
+            "SELECT item_id, proficiency_level, skill_image, icon, effect FROM item_proficiency_perk",
+        ).fetchall()
+        self.assertEqual([(3, 1, "Club Skill Bonus", None, "+1 Club Fighting")], [tuple(row) for row in rows])
+
+
+class TestGenerationOrchestration(unittest.TestCase):
+    def setUp(self):
+        self.conn = sqlite3.connect(":memory:")
+
+    def tearDown(self):
+        self.conn.close()
+
+    def test_skip_category_excludes_fetch_and_parse(self):
+        with (
+            patch("tibiawikisql.generation.fetch_category_entries", return_value=[]) as mock_fetch,
+            patch.object(generation_module.wiki_client, "get_articles", return_value=[]) as mock_get_articles,
+            patch("tibiawikisql.generation.POST_TASKS", ()),
+        ):
+            generation_module.generate(self.conn, skip_categories=("achievements",))
+
+        fetched_categories = [call.args[0] for call in mock_fetch.call_args_list]
+        self.assertNotIn("Achievements", fetched_categories)
+        self.assertEqual(len(generation_module.CATEGORIES) - 1, len(mock_get_articles.call_args_list))
+
+    def test_hard_dependencies_auto_skip_categories(self):
+        with (
+            patch("tibiawikisql.generation.fetch_category_entries", return_value=[]) as mock_fetch,
+            patch.object(generation_module.wiki_client, "get_articles", return_value=[]),
+            patch("tibiawikisql.generation.POST_TASKS", ()),
+            patch("tibiawikisql.generation.click.echo") as mock_echo,
+        ):
+            generation_module.generate(self.conn, skip_categories=("items",))
+
+        fetched_categories = [call.args[0] for call in mock_fetch.call_args_list]
+        self.assertNotIn("Objects", fetched_categories)
+        self.assertNotIn("Keys", fetched_categories)
+        messages = " ".join(call.args[0] for call in mock_echo.call_args_list if call.args)
+        self.assertIn("Skipping category 'keys'", messages)
+
+    def test_post_tasks_are_gated_by_enabled_categories(self):
+        gated_task = Mock()
+        always_task = Mock()
+        post_tasks = (
+            generation_module.PostTask("needs_items", lambda *_: gated_task(), dependencies=("items",)),
+            generation_module.PostTask("always_runs", lambda *_: always_task()),
+        )
+        with (
+            patch("tibiawikisql.generation.fetch_category_entries", return_value=[]),
+            patch.object(generation_module.wiki_client, "get_articles", return_value=[]),
+            patch("tibiawikisql.generation.POST_TASKS", post_tasks),
+            patch("tibiawikisql.generation.click.echo") as mock_echo,
+        ):
+            generation_module.generate(self.conn, skip_categories=("items",))
+
+        gated_task.assert_not_called()
+        always_task.assert_called_once_with()
+        messages = " ".join(call.args[0] for call in mock_echo.call_args_list if call.args)
+        self.assertIn("Skipping task 'needs_items'", messages)
+
+    def test_generate_loot_statistics_early_return_without_maps(self):
+        wiki_client = Mock()
+        generate_loot_statistics(
+            self.conn,
+            {},
+            wiki_client=wiki_client,
+            progress_bar=generation_module.progress_bar,
+            article_label=generation_module.article_label,
+            timed=generation_module.timed,
+            echo=Mock(),
+        )
+        wiki_client.get_articles.assert_not_called()
+
+
+class TestGenerateCommand(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+
+    def test_skip_category_option_is_passed_to_generate(self):
+        with patch("tibiawikisql.__main__.generation.generate") as mock_generate:
+            result = self.runner.invoke(
+                cli_module.cli,
+                [
+                    "generate",
+                    "--db-name",
+                    ":memory:",
+                    "--skip-category",
+                    "achievements",
+                    "--skip-category",
+                    "items",
+                ],
+            )
+        self.assertEqual(0, result.exit_code, result.output)
+        self.assertEqual(("achievements", "items"), mock_generate.call_args.kwargs["skip_categories"])
+
+    def test_skip_category_rejects_invalid_value(self):
+        result = self.runner.invoke(
+            cli_module.cli,
+            [
+                "generate",
+                "--skip-category",
+                "invalid-category",
+            ],
+        )
+        self.assertNotEqual(0, result.exit_code)
+        self.assertIn("Invalid value", result.output)
+        self.assertIn("--skip-category", result.output)

{tibiawikisql-7.0.3 → tibiawikisql-8.0.1}/tests/tests_utils.py

@@ -1,8 +1,11 @@
 import unittest
 
+import datetime
+
 from tests import load_resource
 from tibiawikisql.utils import (clean_links, client_color_to_rgb, parse_boolean, parse_float, parse_integer,
-                                parse_loot_statistics, parse_min_max, parse_sounds)
+                                parse_date, parse_loot_statistics, parse_min_max, parse_sounds,
+                                parse_weapon_proficiency_name, parse_weapon_proficiency_tables)
 
 
 class TestUtils(unittest.TestCase):
@@ -54,6 +57,9 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(parse_integer("10056"), 10056)
         self.assertEqual(parse_integer("--"), 0)
 
+    def test_parse_date_ignores_comma_separated_time(self):
+        self.assertEqual(datetime.date(2026, 1, 27), parse_date("January 27, 2026, 16:00"))
+
     def test_parse_min_max(self):
         self.assertEqual(parse_min_max("5-20"), (5, 20))
         self.assertEqual(parse_min_max("50"), (0, 50))
@@ -81,3 +87,55 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(client_color_to_rgb(3), 0x99)
         self.assertEqual(client_color_to_rgb(215), 0xffffff)
         self.assertEqual(client_color_to_rgb(216), 0)
+
+    def test_parse_weapon_proficiency_name(self):
+        content = load_resource("content_weapon_proficiency_name.txt")
+        mappings = parse_weapon_proficiency_name(content)
+
+        self.assertEqual(2, len(mappings))
+        self.assertEqual("Sanguine 1H Axe", mappings["Amber Axe"])
+        self.assertEqual("Sanguine 1H Club", mappings["Amber Cudgel"])
+        self.assertNotIn("#default", mappings)
+
+    def test_parse_weapon_proficiency_name_without_switch(self):
+        mappings = parse_weapon_proficiency_name("== Not a switch ==")
+        self.assertEqual({}, mappings)
+
+    def test_parse_weapon_proficiency_tables(self):
+        content = load_resource("content_weapon_proficiency_tables.txt")
+        tables = parse_weapon_proficiency_tables(content)
+
+        self.assertIn("Sanguine 1H Axe", tables)
+        self.assertIn("Sanguine 1H Club", tables)
+        self.assertIn(1, tables["Sanguine 1H Axe"])
+        self.assertIn(2, tables["Sanguine 1H Axe"])
+
+        perks = tables["Sanguine 1H Axe"][2]
+        self.assertEqual(3, len(perks))
+        self.assertIsNone(perks[0]["icon"])
+        self.assertEqual("Special Icon", perks[1]["icon"])
+
+    def test_parse_weapon_proficiency_tables_effect_fallback(self):
+        content = """===Sanguine 1H Axe===
+{{Weapon Proficiency Table
+|perk_1 =
+{{Weapon Proficiency Button |skill_image=Axe Skill Bonus|icon=|effect=Fallback Effect}}
+|perk_x =
+{{Weapon Proficiency Button |skill_image=Ignored|icon=|text=Ignored}}
+}}"""
+        tables = parse_weapon_proficiency_tables(content)
+        self.assertIn("Sanguine 1H Axe", tables)
+        self.assertIn(1, tables["Sanguine 1H Axe"])
+        self.assertEqual([1], list(tables["Sanguine 1H Axe"].keys()))
+        self.assertEqual("Fallback Effect", tables["Sanguine 1H Axe"][1][0]["effect"])
+
+    def test_parse_weapon_proficiency_tables_level_two_headings(self):
+        content = """==Sanguine 1H Axe==
+{{Weapon Proficiency Table
+|perk_1 =
+{{Weapon Proficiency Button |skill_image=Axe Skill Bonus|icon=|text=+1 Axe Fighting}}
+}}"""
+        tables = parse_weapon_proficiency_tables(content)
+        self.assertIn("Sanguine 1H Axe", tables)
+        self.assertIn(1, tables["Sanguine 1H Axe"])
+        self.assertEqual("+1 Axe Fighting", tables["Sanguine 1H Axe"][1][0]["effect"])

{tibiawikisql-7.0.3 → tibiawikisql-8.0.1}/tibiawikisql/__init__.py

@@ -4,4 +4,4 @@ __author__ = "Allan Galarza"
 __copyright__ = "Copyright 2025 Allan Galarza"
 
 __license__ = "Apache 2.0"
-__version__ = "7.0.3"
+__version__ = "8.0.1"

tibiawikisql-8.0.1/tibiawikisql/__main__.py

@@ -0,0 +1,62 @@
+"""Command line interface for tibiawiki-sql."""
+
+import sqlite3
+
+import click
+import colorama
+
+from tibiawikisql import __version__, generation
+from tibiawikisql.utils import timed
+
+DATABASE_FILE = "tibiawiki.db"
+PARSING_ERRORS_FILE = "parsing-errors.log"
+
+colorama.init()
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(__version__, "-V", "--version")
+def cli() -> None:
+    """Run tibiawiki-sql commands."""
+
+
+@cli.command(name="generate")
+@click.option("-i", "--skip-images", help="Skip fetching and loading images to the database.", is_flag=True)
+@click.option("-o", "--db-name", help="Name for the database file.", default=DATABASE_FILE)
+@click.option("-d", "--skip-deprecated", help="Skips fetching deprecated articles and their images.", is_flag=True)
+@click.option(
+    "--log-parsing-errors",
+    help=f"Write every parsing error to {PARSING_ERRORS_FILE}.",
+    is_flag=True,
+)
+@click.option(
+    "-c",
+    "--skip-category",
+    "skip_categories",
+    multiple=True,
+    type=click.Choice(sorted(generation.CATEGORIES), case_sensitive=False),
+    help=(
+        "Skip specific categories. Can be repeated."
+    ),
+)
+def generate(
+    skip_images: bool,
+    db_name: str,
+    skip_deprecated: bool,
+    log_parsing_errors: bool,
+    skip_categories: tuple[str, ...],
+) -> None:
+    """Generates a database file."""
+    with timed() as t, sqlite3.connect(db_name) as conn:
+        generation.generate(
+            conn,
+            skip_images=skip_images,
+            skip_deprecated=skip_deprecated,
+            skip_categories=skip_categories,
+            parsing_errors_file=PARSING_ERRORS_FILE if log_parsing_errors else None,
+        )
+    click.echo(f"Command finished in {t.elapsed:.2f} seconds.")
+
+
+if __name__ == "__main__":
+    cli()