kunyi 0.1.0__py3-none-any.whl

kunyi/__init__.py

@@ -0,0 +1,6 @@
+"""kunyi — generate Anki .apkg decks from structured card data."""
+
+from kunyi.card_types import BasicCard, MCQCard
+from kunyi.deck import AnkiCardDeck
+
+__all__ = ["AnkiCardDeck", "BasicCard", "MCQCard"]

kunyi/__main__.py

@@ -0,0 +1,142 @@
+"""CLI entry point for kunyi.
+
+Usage
+-----
+    kunyi <deck_name> <input_file> [--format {json,tsv}] [--output PATH]
+
+On success:  the resolved output path is printed to stdout, exit 0.
+On failure:  a human-readable message is printed to stderr, exit 1.
+
+This contract is designed for subprocess callers (e.g. Seya/Dart):
+  - check the exit code
+  - on 0: read stdout as the .apkg path
+  - on non-zero: read stderr for the error message
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from kunyi.card_types import BasicCard, MCQCard
+from kunyi.deck import AnkiCardDeck
+from kunyi.parsers import parse_json, parse_tsv
+
+
+def _detect_format(path: Path) -> str:
+    """Infer input format from file extension.
+
+    Parameters
+    ----------
+    path:
+        Input file path.
+
+    Returns
+    -------
+    str
+        "json" or "tsv".
+
+    Raises
+    ------
+    ValueError
+        If the extension is not recognised.
+    """
+    suffix = path.suffix.lower()
+    if suffix == ".json":
+        return "json"
+    if suffix in {".tsv", ".txt"}:
+        return "tsv"
+    raise ValueError(
+        f"Cannot infer format from extension {suffix!r}. "
+        "Use --format {{json,tsv}} to specify explicitly."
+    )
+
+
+def _resolve_output(deck_name: str, output: str | None) -> Path:
+    """Resolve the .apkg output path.
+
+    Parameters
+    ----------
+    deck_name:
+        Deck name used to build the default filename.
+    output:
+        Explicit output path from --output, or None for the default.
+
+    Returns
+    -------
+    Path
+        Resolved output path.
+    """
+    if output is not None:
+        return Path(output)
+    safe_name = deck_name.replace(" ", "_")
+    return Path(f"{safe_name}.apkg")
+
+
+def main() -> None:
+    """Parse arguments and generate the .apkg deck."""
+    parser = argparse.ArgumentParser(
+        prog="kunyi",
+        description="Generate an Anki .apkg deck from JSON or TSV card data.",
+    )
+    parser.add_argument("deck_name", help="Name of the Anki deck.")
+    parser.add_argument("input_file", help="Path to the input file (.json or .tsv).")
+    parser.add_argument(
+        "--format",
+        choices=["json", "tsv"],
+        default=None,
+        help="Input format. Defaults to auto-detection by file extension.",
+    )
+    parser.add_argument(
+        "--output",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Output path for the .apkg file. "
+            "Defaults to <deck_name>.apkg in the current directory."
+        ),
+    )
+
+    args = parser.parse_args()
+    input_path = Path(args.input_file)
+
+    # Resolve format: explicit flag wins over extension detection.
+    try:
+        fmt = args.format or _detect_format(input_path)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # Parse input file.
+    try:
+        if fmt == "json":
+            cards: list[BasicCard | MCQCard] = parse_json(input_path)
+        else:
+            cards = parse_tsv(input_path)
+    except FileNotFoundError:
+        print(f"error: input file not found: {input_path}", file=sys.stderr)
+        sys.exit(1)
+    except (KeyError, ValueError) as exc:
+        print(f"error: failed to parse {input_path}: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # Build and save deck.
+    output_path = _resolve_output(args.deck_name, args.output)
+
+    try:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        deck = AnkiCardDeck(deck_name=args.deck_name)
+        for card in cards:
+            deck.add_card(card)
+        deck.save_deck(output_path)
+    except Exception as exc:  # noqa: BLE001
+        print(f"error: failed to write deck: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # Print resolved path to stdout for subprocess callers.
+    print(output_path.resolve())
+
+
+if __name__ == "__main__":
+    main()

kunyi/card_types.py

@@ -0,0 +1,70 @@
+"""Card type dataclasses for kunyi.
+
+Each dataclass is a pure data container with no genanki dependency.
+Optional fields (tags, media_paths) are reserved for future use and map
+directly to genanki.Note(tags=...) and genanki.Package(media_files=...).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class BasicCard:
+    """A simple two-sided flashcard.
+
+    Parameters
+    ----------
+    front:
+        Text rendered on the question side of the card.
+    back:
+        Text rendered on the answer side of the card.
+    tags:
+        Optional Anki tags attached to the note (e.g. ["chapter-3", "exam"]).
+    media_paths:
+        Optional paths to media files (images, audio) referenced by this card.
+        Collected at deck-save time and registered with the genanki Package.
+    """
+
+    front: str
+    back: str
+    tags: list[str] = field(default_factory=list)
+    media_paths: list[Path] = field(default_factory=list)
+
+
+@dataclass
+class MCQCard:
+    """A multiple-choice question card.
+
+    Parameters
+    ----------
+    question:
+        The question stem displayed on the front of the card.
+    choices:
+        Ordered list of answer options shown below the question.
+    correct_answer:
+        The correct choice string; must be an element of *choices*.
+        Validated on construction so upstream LLM output is caught early.
+    explanation:
+        Explanation of the correct answer displayed on the card back.
+    tags:
+        Optional Anki tags attached to the note.
+    media_paths:
+        Optional paths to media files referenced by this card.
+    """
+
+    question: str
+    choices: list[str]
+    correct_answer: str
+    explanation: str
+    tags: list[str] = field(default_factory=list)
+    media_paths: list[Path] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        """Validate that correct_answer is a member of choices."""
+        if self.correct_answer not in self.choices:
+            raise ValueError(
+                f"correct_answer {self.correct_answer!r} is not in choices: {self.choices}"
+            )

kunyi/deck.py

@@ -0,0 +1,191 @@
+"""Deck orchestration for kunyi.
+
+AnkiCardDeck wraps a genanki.Deck and handles model selection, note
+construction, and media collection. It accepts both BasicCard and MCQCard
+objects via a single add_card() method and dispatches internally.
+"""
+
+from __future__ import annotations
+
+import random
+import time
+from pathlib import Path
+from typing import Union
+
+import genanki
+
+from kunyi.card_types import BasicCard, MCQCard
+from kunyi.models import basic_model, mcq_model
+
+Card = Union[BasicCard, MCQCard]
+
+
+class AnkiCardDeck:
+    """Build an Anki deck from BasicCard and MCQCard objects.
+
+    A single deck can hold mixed card types. Each type uses its own genanki
+    Model (keyed by a deterministic model_id derived from deck_id). Notes are
+    added in insertion order.
+
+    Media file paths collected from card.media_paths are passed to
+    genanki.Package at save time. The actual media wiring is reserved — files
+    are registered but card templates do not yet reference them by name.
+
+    Parameters
+    ----------
+    deck_name:
+        Human-readable name shown in Anki.
+    deck_id:
+        Optional stable integer deck ID. Defaults to a time-based value.
+        Use a fixed value when regenerating the same deck so Anki updates
+        existing notes instead of creating duplicates.
+    """
+
+    def __init__(
+        self,
+        deck_name: str,
+        deck_id: int | None = None,
+    ) -> None:
+        self.deck_name = deck_name
+        self.deck_id: int = deck_id if deck_id is not None else int(time.time())
+
+        # Derive stable model IDs from deck_id so they travel together.
+        self._basic_model: genanki.Model = basic_model(self.deck_id + 1)
+        self._mcq_model: genanki.Model = mcq_model(self.deck_id + 2)
+
+        self._deck: genanki.Deck = genanki.Deck(self.deck_id, self.deck_name)
+        self._media_files: list[str] = []
+
+    # ------------------------------------------------------------------
+    # Public interface
+    # ------------------------------------------------------------------
+
+    def add_card(self, card: Card) -> None:
+        """Add a single card to the deck.
+
+        Dispatches to the correct note builder based on card type.
+
+        Parameters
+        ----------
+        card:
+            A BasicCard or MCQCard instance.
+
+        Raises
+        ------
+        TypeError
+            If card is not a recognised card type.
+        """
+        if isinstance(card, BasicCard):
+            note = self._build_basic_note(card)
+        elif isinstance(card, MCQCard):
+            note = self._build_mcq_note(card)
+        else:
+            raise TypeError(f"Unsupported card type: {type(card)!r}")
+
+        self._deck.add_note(note)
+
+        # Accumulate media for registration at save time.
+        for media_path in card.media_paths:
+            self._media_files.append(str(media_path))
+
+    def save_deck(self, output_path: Path) -> None:
+        """Write the deck to an .apkg file.
+
+        Parameters
+        ----------
+        output_path:
+            Destination path for the .apkg file. Parent directories must
+            already exist; callers are responsible for creation.
+        """
+        package = genanki.Package(self._deck)
+        # Media wiring: reserved for future use. Files are registered here
+        # so the field exists in the package; card templates will reference
+        # them by filename once image/audio card types are added.
+        if self._media_files:
+            package.media_files = self._media_files
+
+        package.write_to_file(str(output_path))
+
+    # ------------------------------------------------------------------
+    # Private note builders
+    # ------------------------------------------------------------------
+
+    def _build_basic_note(self, card: BasicCard) -> genanki.Note:
+        """Construct a genanki Note from a BasicCard.
+
+        Parameters
+        ----------
+        card:
+            Source BasicCard.
+
+        Returns
+        -------
+        genanki.Note
+            Note bound to the basic model with Front and Back fields.
+        """
+        return genanki.Note(
+            model=self._basic_model,
+            fields=[card.front, card.back],
+            tags=card.tags,
+        )
+
+    def _build_mcq_note(self, card: MCQCard) -> genanki.Note:
+        """Construct a genanki Note from an MCQCard.
+
+        The Question field contains the formatted question stem and numbered
+        choices separated by HTML line breaks. The Answer field contains the
+        correct answer and explanation in bold-labelled HTML.
+
+        Parameters
+        ----------
+        card:
+            Source MCQCard.
+
+        Returns
+        -------
+        genanki.Note
+            Note bound to the MCQ model.
+        """
+        return genanki.Note(
+            model=self._mcq_model,
+            fields=[
+                self._format_mcq_front(card),
+                self._format_mcq_back(card),
+            ],
+            tags=card.tags,
+        )
+
+    @staticmethod
+    def _format_mcq_front(card: MCQCard) -> str:
+        """Render the front HTML for an MCQCard.
+
+        Parameters
+        ----------
+        card:
+            Source MCQCard.
+
+        Returns
+        -------
+        str
+            HTML string: question stem followed by numbered choices.
+        """
+        numbered = "<br>".join(f"{i}. {c}" for i, c in enumerate(card.choices, 1))
+        return f"{card.question}<br><br>{numbered}"
+
+    @staticmethod
+    def _format_mcq_back(card: MCQCard) -> str:
+        """Render the back HTML for an MCQCard.
+
+        Parameters
+        ----------
+        card:
+            Source MCQCard.
+
+        Returns
+        -------
+        str
+            HTML string: bolded correct answer label followed by explanation.
+        """
+        answer_line = f"<strong>Correct answer:</strong> {card.correct_answer}<br><br>"
+        explanation_line = f"<strong>Explanation:</strong> {card.explanation}"
+        return answer_line + explanation_line

kunyi/models.py

@@ -0,0 +1,73 @@
+"""Genanki model factories for each card type.
+
+Each factory returns a configured genanki.Model. Keeping model construction
+here isolates the Anki-specific template/field schema from deck orchestration
+in deck.py. To add a new card type, add a new factory here and register it
+in deck.py's dispatch logic.
+"""
+
+import genanki
+
+
+def basic_model(model_id: int) -> genanki.Model:
+    """Return a genanki Model for BasicCard (front / back).
+
+    Parameters
+    ----------
+    model_id:
+        Unique integer ID for the model. Caller is responsible for stability
+        across regenerations so Anki can match notes to the correct model.
+
+    Returns
+    -------
+    genanki.Model
+        A two-field model rendering Front on the question side and Back on
+        the answer side.
+    """
+    return genanki.Model(
+        model_id,
+        "Basic",
+        fields=[
+            {"name": "Front"},
+            {"name": "Back"},
+        ],
+        templates=[
+            {
+                "name": "Card 1",
+                "qfmt": "{{Front}}",
+                "afmt": "{{FrontSide}}<hr id=answer>{{Back}}",
+            },
+        ],
+    )
+
+
+def mcq_model(model_id: int) -> genanki.Model:
+    """Return a genanki Model for MCQCard (question + choices / answer + explanation).
+
+    Parameters
+    ----------
+    model_id:
+        Unique integer ID for the model.
+
+    Returns
+    -------
+    genanki.Model
+        A two-field model where the Question field contains the formatted
+        question + numbered choices and the Answer field contains the correct
+        answer and explanation.
+    """
+    return genanki.Model(
+        model_id,
+        "MCQ with explanation",
+        fields=[
+            {"name": "Question"},
+            {"name": "Answer"},
+        ],
+        templates=[
+            {
+                "name": "Card 1",
+                "qfmt": "{{Question}}",
+                "afmt": "{{FrontSide}}<hr id=answer>{{Answer}}",
+            },
+        ],
+    )

kunyi/parsers.py

@@ -0,0 +1,120 @@
+"""Input parsers for kunyi.
+
+Each parser reads a file and returns a list of typed card objects.
+Supported formats:
+  - JSON: MCQCard list (see README for schema)
+  - TSV:  BasicCard list with columns front<TAB>back (optional header row)
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+
+from kunyi.card_types import BasicCard, MCQCard
+
+
+def parse_json(path: Path) -> list[MCQCard]:
+    """Parse a JSON file into a list of MCQCard objects.
+
+    Expected schema::
+
+        {
+          "cards": [
+            {
+              "question": "...",
+              "choices": ["A", "B", "C", "D"],
+              "correct_answer": "A",
+              "explanation": "..."
+            }
+          ]
+        }
+
+    The top-level "deck_name" key is ignored here; callers pass deck_name
+    separately so the parser stays stateless.
+
+    Parameters
+    ----------
+    path:
+        Path to the JSON file.
+
+    Returns
+    -------
+    list[MCQCard]
+        Parsed and validated card objects.
+
+    Raises
+    ------
+    KeyError
+        If a required field is missing from a card entry.
+    ValueError
+        If correct_answer is not in choices (propagated from MCQCard).
+    """
+    with path.open(encoding="utf-8") as fh:
+        data: dict = json.load(fh)
+
+    cards: list[MCQCard] = []
+    for entry in data["cards"]:
+        cards.append(
+            MCQCard(
+                question=entry["question"],
+                choices=entry["choices"],
+                correct_answer=entry["correct_answer"],
+                explanation=entry["explanation"],
+                tags=entry.get("tags", []),
+            )
+        )
+    return cards
+
+
+def parse_tsv(path: Path) -> list[BasicCard]:
+    """Parse a TSV file into a list of BasicCard objects.
+
+    The file must be tab-delimited UTF-8. An optional header row is detected
+    automatically: if the first row contains the literal values "front" and
+    "back" (case-insensitive) it is skipped. All other rows are treated as
+    card data.
+
+    Expected layout::
+
+        front<TAB>back
+        What is spaced repetition?<TAB>A technique that spaces reviews over time.
+
+    Parameters
+    ----------
+    path:
+        Path to the TSV file.
+
+    Returns
+    -------
+    list[BasicCard]
+        Parsed card objects.
+
+    Raises
+    ------
+    ValueError
+        If a row does not have at least two tab-separated columns.
+    """
+    cards: list[BasicCard] = []
+
+    with path.open(encoding="utf-8", newline="") as fh:
+        reader = csv.reader(fh, delimiter="\t")
+        rows = list(reader)
+
+    if not rows:
+        return cards
+
+    # Detect and skip header row.
+    first = rows[0]
+    if len(first) >= 2 and first[0].strip().lower() == "front" and first[1].strip().lower() == "back":
+        rows = rows[1:]
+
+    for i, row in enumerate(rows, start=2):  # line numbers for error messages
+        if len(row) < 2:
+            raise ValueError(
+                f"TSV row {i} has fewer than 2 columns: {row!r}"
+            )
+        cards.append(BasicCard(front=row[0].strip(), back=row[1].strip()))
+
+    return cards

kunyi-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: kunyi
+Version: 0.1.0
+Summary: Generate Anki .apkg decks from JSON (MCQ) or TSV (basic) card data.
+Project-URL: Homepage, https://github.com/LingT03/Kunyi
+Project-URL: Bug Tracker, https://github.com/LingT03/Kunyi/issues
+Project-URL: Changelog, https://github.com/LingT03/Kunyi/releases
+License: PolyForm Noncommercial License 1.0.0
+        
+        https://polyformproject.org/licenses/noncommercial/1.0.0
+        
+        Required Notice: Copyright Ta'taang (Ling Thang) (https://github.com/LingT03)
+        
+        Acceptance
+        
+        In order to get any license under these terms, you must agree
+        to them as both strict obligations and conditions to all
+        your licenses.
+        
+        Copyright License
+        
+        The licensor grants you a copyright license for the
+        software to do everything you might do with the software
+        that would otherwise infringe the licensor's copyright
+        in it for any permitted purpose. However, you may
+        only distribute the software according to Distribution License
+        and make changes or new works based on the software according
+        to Changes and New Works License.
+        
+        Distribution License
+        
+        The licensor grants you an additional copyright license
+        to distribute copies of the software. Your license
+        to distribute covers distributing the software with
+        changes and new works permitted by Changes and New Works License.
+        
+        Notices
+        
+        You must ensure that anyone who gets a copy of any part of
+        the software from you also gets a copy of these terms or the
+        URL for them above, as well as copies of any plain-text lines
+        beginning with "Required Notice:" that the licensor provided
+        with the software.
+        
+        Changes and New Works License
+        
+        The licensor grants you an additional copyright license to
+        make changes and new works based on the software for any
+        permitted purpose.
+        
+        Patent License
+        
+        The licensor grants you a patent license for the software that
+        covers patent claims the licensor can license, or becomes able
+        to license, that you would infringe by using the software.
+        
+        Noncommercial Purposes
+        
+        Any noncommercial purpose is a permitted purpose.
+        
+        Personal Uses
+        
+        Personal use for research, experiment, and testing for
+        the benefit of public knowledge, personal study, private
+        entertainment, hobby projects, amateur pursuits, or religious
+        observance, without any anticipated commercial application,
+        is use for a permitted purpose.
+        
+        Noncommercial Organizations
+        
+        Use by any charitable organization, educational institution,
+        public research organization, public safety or health
+        organization, environmental protection organization,
+        or government institution is use for a permitted purpose
+        regardless of the source of funding or obligations resulting
+        from the funding.
+        
+        Fair Use
+        
+        You may have "fair use" rights for the software under the
+        law. These terms do not limit them.
+        
+        No Other Rights
+        
+        These terms do not allow you to sublicense or transfer any of
+        your licenses to anyone else, or prevent the licensor from
+        granting licenses to anyone else. These terms do not imply
+        any other licenses.
+        
+        Patent Defense
+        
+        If you make any written claim that the software infringes or
+        contributes to infringement of any patent, your patent license
+        for the software granted under these terms ends immediately. If
+        your company makes such a claim, your patent license ends
+        immediately for work on behalf of your company.
+        
+        Violations
+        
+        The first time you are notified in writing that you have
+        violated any of these terms, or done anything with the software
+        not covered by your licenses, your licenses can nonetheless
+        continue if you come into full compliance with these terms,
+        and take practical steps to correct past violations, within
+        32 days of receiving notice. Otherwise, all your licenses
+        end immediately.
+        
+        No Liability
+        
+        AS FAR AS THE LAW ALLOWS, THE SOFTWARE COMES AS IS, WITHOUT
+        ANY WARRANTY OR CONDITION, AND THE LICENSOR WILL NOT BE LIABLE
+        TO YOU FOR ANY DAMAGES ARISING OUT OF THESE TERMS OR THE USE
+        OR NATURE OF THE SOFTWARE, UNDER ANY KIND OF LEGAL CLAIM.
+        
+        Definitions
+        
+        The "licensor" is the individual or entity offering these
+        terms, and the "software" is the software the licensor makes
+        available under these terms.
+        
+        "You" refers to the individual or entity agreeing to these
+        terms.
+        
+        "Your company" is any legal entity, sole proprietorship,
+        or other kind of organization that you work for, plus all
+        organizations that have control over, are under the control of,
+        or are under common control with that organization. "Control"
+        means ownership of substantially all the assets of an entity,
+        or the power to direct its management and policies by vote,
+        contract, or otherwise. Control can be direct or indirect.
+        
+        "Your licenses" are all the licenses granted to you for the
+        software under these terms.
+        
+        "Use" means anything you do with the software requiring one
+        of your licenses.
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: genanki>=0.13
+Description-Content-Type: text/markdown
+
+# kunyi
+
+Generate Anki `.apkg` decks from JSON (MCQ) or TSV (basic) card data.
+
+_Part of the [Seya](https://github.com/LingT03/Seya) study ecosystem._
+
+---
+
+## Installation
+
+```bash
+pip install kunyi
+```
+
+Or for local development:
+
+```bash
+git clone https://github.com/LingT03/Kunyi.git
+cd Kunyi
+pip install -e .
+```
+
+---
+
+## CLI usage
+
+```bash
+# JSON — multiple-choice question cards
+kunyi "Cloud Computing" cards.json
+
+# TSV — basic front/back cards
+kunyi "Calc 2 Formulas" formulas.tsv
+
+# Explicit output path (recommended for subprocess callers)
+kunyi "Cloud Computing" cards.json --output /path/to/deck.apkg
+
+# Override format detection
+kunyi "My Deck" cards.data --format tsv
+```
+
+On success the resolved `.apkg` path is printed to stdout (exit 0).  
+On failure a human-readable message is printed to stderr (exit 1).
+
+---
+
+## Input formats
+
+### JSON — MCQ cards
+
+```json
+{
+  "cards": [
+    {
+      "question": "What does CPU stand for?",
+      "choices": ["Central Processing Unit", "Core Power Unit", "Control Processing Unit"],
+      "correct_answer": "Central Processing Unit",
+      "explanation": "CPU stands for Central Processing Unit.",
+      "tags": ["chapter-1"]
+    }
+  ]
+}
+```
+
+`correct_answer` must be an element of `choices` — validated on parse.  
+`tags` is optional.
+
+### TSV — basic cards
+
+Tab-delimited UTF-8. Optional header row (`front\tback`) is auto-detected and skipped.
+
+```
+front	back
+What is spaced repetition?	A technique that spaces reviews over time.
+What is active recall?	Actively retrieving information from memory.
+```
+
+---
+
+## Library usage
+
+```python
+from pathlib import Path
+from kunyi import AnkiCardDeck, MCQCard, BasicCard
+
+deck = AnkiCardDeck(deck_name="My Deck")
+
+deck.add_card(MCQCard(
+    question="What does RAM stand for?",
+    choices=["Random Access Memory", "Read Access Module"],
+    correct_answer="Random Access Memory",
+    explanation="RAM is the primary short-term memory of a computer.",
+    tags=["hardware"],
+))
+
+deck.add_card(BasicCard(
+    front="What is a CPU?",
+    back="The central processing unit — the brain of a computer.",
+))
+
+deck.save_deck(Path("output/my_deck.apkg"))
+```
+
+---
+
+## Running tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+---
+
+## What is Anki?
+
+[Anki](https://apps.ankiweb.net/) is a free flashcard program that uses spaced repetition and active recall to maximise long-term retention. `kunyi` generates `.apkg` files that can be imported directly into Anki.

kunyi-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+kunyi/__init__.py,sha256=t7HHuKT_JQWr_1GXqJVbD-BX6BRvvyJzh4RfOc57NOU,206
+kunyi/__main__.py,sha256=NAGinrW6d1GFzZydJLxhn_Bf_MPth5we605xcDbteO8,3874
+kunyi/card_types.py,sha256=WPs0Uu_M_3nebQuIZ3x9NhlEHdryMrYVPb9_jWrvvrs,2130
+kunyi/deck.py,sha256=wldRYiothHuMYQbvk2aWBtIEPw076UKS6dp48N0O5ls,5970
+kunyi/models.py,sha256=kGhC7Y2W5QnBbjHFP33UzHfPWsu7TrX3Xb8abLaNvkQ,1967
+kunyi/parsers.py,sha256=ZBwgcgDEdlcBQ6atFOBozykLCitMACWPQhu4BnY-MJc,3095
+kunyi-0.1.0.dist-info/METADATA,sha256=vwHlhXfUDDuPoiYaz0mNzU7_ajyV1pZNuhfHdP2q6BM,8325
+kunyi-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kunyi-0.1.0.dist-info/entry_points.txt,sha256=wFzkP73VrsnCbZ-uGLjLyig_2JXcUQLoa0vKkC9Gfg4,46
+kunyi-0.1.0.dist-info/licenses/LICENSE,sha256=vkeG3u7f9pHcvQEh8vK8sbe1yV2jcbaeEzux__ru1ng,4394
+kunyi-0.1.0.dist-info/RECORD,,

kunyi-0.1.0.dist-info/WHEEL

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

kunyi-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kunyi = kunyi.__main__:main

kunyi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,129 @@
+PolyForm Noncommercial License 1.0.0
+
+https://polyformproject.org/licenses/noncommercial/1.0.0
+
+Required Notice: Copyright Ta'taang (Ling Thang) (https://github.com/LingT03)
+
+Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose. However, you may
+only distribute the software according to Distribution License
+and make changes or new works based on the software according
+to Changes and New Works License.
+
+Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software. Your license
+to distribute covers distributing the software with
+changes and new works permitted by Changes and New Works License.
+
+Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with "Required Notice:" that the licensor provided
+with the software.
+
+Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice. Otherwise, all your licenses
+end immediately.
+
+No Liability
+
+AS FAR AS THE LAW ALLOWS, THE SOFTWARE COMES AS IS, WITHOUT
+ANY WARRANTY OR CONDITION, AND THE LICENSOR WILL NOT BE LIABLE
+TO YOU FOR ANY DAMAGES ARISING OUT OF THESE TERMS OR THE USE
+OR NATURE OF THE SOFTWARE, UNDER ANY KIND OF LEGAL CLAIM.
+
+Definitions
+
+The "licensor" is the individual or entity offering these
+terms, and the "software" is the software the licensor makes
+available under these terms.
+
+"You" refers to the individual or entity agreeing to these
+terms.
+
+"Your company" is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. "Control"
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+"Your licenses" are all the licenses granted to you for the
+software under these terms.
+
+"Use" means anything you do with the software requiring one
+of your licenses.