hanky 0.3.0.dev0__tar.gz → 0.3.0.dev1__tar.gz

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanky
-Version: 0.3.0.dev0
+Version: 0.3.0.dev1
 Summary: Simple library and command line tool for loading flash cards into anki.
 Project-URL: Homepage, https://github.com/Haeata-Ash/hanky
 Project-URL: Issues, https://github.com/Haeata-Ash/hanky/issues
@@ -68,18 +68,18 @@ See [Card Processors & Pipelines](#card-processors--pipelines) or the [demo fold
 from hanky import HankyPipeline
 
 
-# instantiate the hanky app
-hanky = HankyPipeline()
+# instantiate the hanky app, creating cards with the "basic" model
+hanky = HankyPipeline("basic")
 
 
-@hanky.card_processor("basic", expected_args=[], card_fields=[])
+@hanky.card_processor(expected_args=[], card_fields=[])
 def lowercase_card(card: dict):
     """Lower-case the text on every field of the card."""
     return {field: value.lower() for field, value in card.items()}
 
 
 # run the hanky cli application by running this python file, for example:
-#   python3 my_script.py pipe words.csv --model basic --into english::vocab
+#   python3 my_script.py pipe words.csv --into english::vocab
 hanky.run()
 
 ```
@@ -100,10 +100,10 @@ Ephemeral,Lasting A VERY Short Time
 We would run our new script like so
 
 ```sh
-python3 my_script.py pipe words.csv --model basic --into english::vocab
+python3 my_script.py pipe words.csv --into english::vocab
 ```
 
-Here we tell hanky to **pipe** each word in `words.csv` through our `card_processors`, **transforming** each line of the csv with the `lowercase_card`, before finally adding each card, of note type `basic`, into the anki deck `english::vocab`.
+Here we tell hanky to **pipe** each word in `words.csv` through our `card_processors`, **transforming** each line of the csv with the `lowercase_card`, before finally adding each card, of note type `basic` (the model we set on the pipeline), into the anki deck `english::vocab`. A single run can target a different model by passing `--model`.
 
 This would leave us with a **english::vocab** deck containing the following cards:
 
@@ -155,7 +155,7 @@ over the file). Useful if you want different config for different scripts:
 from hanky import HankyPipeline
 from hanky.config import Config
 
-hanky = HankyPipeline(config=Config(ALLOW_DUPLICATES=True))
+hanky = HankyPipeline("basic", config=Config(ALLOW_DUPLICATES=True))
 ```
 
 ## Card Processors & Pipelines
@@ -168,17 +168,20 @@ Multiple processors can be registered on a `HankyPipeline` app to create a pipel
 
 ### The processor contract
 
-A processor is registered with three things:
+Processors are model-agnostic: the Anki model/note-type is set once on the
+pipeline itself (`HankyPipeline("basic")`), and every card the pipeline adds is
+created with that model (unless overridden for a run with `--model`).
+
+A processor is registered with two things:
 
 ```python
-@hanky.card_processor(model, expected_args=[...], card_fields=[...])
+@hanky.card_processor(expected_args=[...], card_fields=[...])
 def my_processor(card: dict, **expected_args):
     ...
 ```
 
 | Part | Meaning |
 | --- | --- |
-| `model` | The Anki model/note-type name. The processor runs on every card of this model. |
 | `expected_args` | Names of CLI arguments the processor needs. They are passed in from the command line via `--args key=value` and arrive as keyword arguments. For example, you might have the same pipeline for different languages, so you would pass in `lang=german` or `lang=french`|
 | `card_fields` | Fields that **must already be present** on the card when this processor runs. Hanky checks this and raises a clear error if one is missing. It lets a processor declare what an *earlier* step must have produced. |
 
@@ -186,7 +189,7 @@ When hanky calls your processors, the first argument is always the `card`; a pla
 
 
 ```python
-@hanky.card_processor(model, expected_args=["lang"], card_fields=[...])
+@hanky.card_processor(expected_args=["lang"], card_fields=[...])
 def my_processor(card: dict, lang):
     ...
 ```
@@ -240,10 +243,10 @@ def scrape_wordreference(word: str, lang_pair: str) -> tuple[str, str]:
 def generate_neural_speech(utf_8_str: str, voice: str) -> bytes:
     ...
 
-hanky = HankyPipeline()
+hanky = HankyPipeline("lang-vocab")
 
 # Stage 1: requires `word` (this comes straight from the csv), produces `translation` + `example`.
-@hanky.card_processor("lang-vocab", expected_args=[], card_fields=["word"])
+@hanky.card_processor(expected_args=[], card_fields=["word"])
 def scrape_translation(card: dict):
     translation, example = scrape_wordreference(card["word"], "enfr")
     card["translation"] = translation
@@ -251,7 +254,7 @@ def scrape_translation(card: dict):
     return card
 
 # Stage 2: requires `translation` (from stage 1), attaches audio media.
-@hanky.card_processor("lang-vocab", expected_args=[], card_fields=["translation"])
+@hanky.card_processor(expected_args=[], card_fields=["translation"])
 def add_audio(card: dict):
     speech = generate_neural_speech(card["translation"], voice="Lea")
     audio = CardMedia(speech, ".mp3")
@@ -261,9 +264,9 @@ def add_audio(card: dict):
 hanky.run()
 ```
 
-Then we would run the script like normal. `python3 my_script.py pipe words.xlsx --model lang-vocab --into french::vocab`
+Then we would run the script like normal. `python3 my_script.py pipe words.xlsx --into french::vocab`
 
-> Note that we are no longer using a *basic* model. That means we are assuming that a model called *lang-vocab* has already been created in the anki ui. See the [Anki documentation for adding a note type](https://docs.ankiweb.net/editing.html#adding-a-note-type) to learn how this is done.
+> Note that this pipeline was created with the *lang-vocab* model rather than *basic*. That means we are assuming that a model called *lang-vocab* has already been created in the anki ui. See the [Anki documentation for adding a note type](https://docs.ankiweb.net/editing.html#adding-a-note-type) to learn how this is done.
 
 
 ### Attaching media
@@ -322,7 +325,7 @@ DICTIONARY = {
     # ...
 }
 
-hanky = HankyPipeline()
+hanky = HankyPipeline("basic")
 
 
 def random_word_cards(n):
@@ -331,7 +334,7 @@ def random_word_cards(n):
 
 
 # add 20 cards straight from the generator, with no file involved
-report = hanky.import_from_source(random_word_cards(20), "basic", "english::vocab")
+report = hanky.import_from_source(random_word_cards(20), "english::vocab")
 print(f"Added {report.added}, skipped {report.skipped}, failed {report.failed}.")
 ```
 
@@ -367,15 +370,20 @@ from simplest to most involved. Install their dependencies with
 Both the `hanky` command and your own scripts share the same interface:
 
 ```
-[hanky | python3 my_script.py] <operation> <file|dir> [pattern] --model MODEL [options]
+[hanky | python3 my_script.py] <operation> <file|dir> [pattern] [options]
 ```
 
+Cards are created with the model set on the pipeline (`HankyPipeline("basic")`);
+pass `-m/--model` to override it for a single run. The standalone `hanky`
+command has no script of its own, so it uses Anki's built-in `Basic` model
+unless you override it.
+
 **`pipe`** — pipe cards from a single file into a deck:
 
 ```
-hanky pipe [-h] -m MODEL [--into DECK] [--fail-fast] [--args K=V ...] file
+hanky pipe [-h] [-m MODEL] [--into DECK] [--fail-fast] [--args K=V ...] file
   file          File to load from (.csv, .json, or a registered extension).
-  -m, --model   Anki model/note-type name to create cards with. Required.
+  -m, --model   Override the Anki model/note-type name to create cards with.
   --into        Destination deck. Defaults to the filename without extension.
   --fail-fast   Stop and raise on the first card that can't be added, instead
                 of skipping it and reporting it at the end.
@@ -385,10 +393,10 @@ hanky pipe [-h] -m MODEL [--into DECK] [--fail-fast] [--args K=V ...] file
 **`pipe-dir`** — pipe many files from a directory, deriving deck names from paths:
 
 ```
-hanky pipe-dir [-h] -m MODEL [-r] [--fail-fast] [--args K=V ...] dir pattern
+hanky pipe-dir [-h] [-m MODEL] [-r] [--fail-fast] [--args K=V ...] dir pattern
   dir              Directory to load from.
   pattern          Glob selecting files, e.g. "*.csv".
-  -m, --model      Anki model/note-type name to create cards with. Required.
+  -m, --model      Override the Anki model/note-type name to create cards with.
   -r, --recursive  Also descend into sub-directories.
   --fail-fast      Stop and raise on the first card that can't be added, instead
                    of skipping it and reporting it at the end.
@@ -399,7 +407,7 @@ For example, to load every CSV under `french/` while building deck names from
 the folder structure:
 
 ```sh
-hanky pipe-dir "french/" "*.csv" --model basic -r
+hanky pipe-dir "french/" "*.csv" -r
 ```
 
 ```

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/README.md

@@ -50,18 +50,18 @@ See [Card Processors & Pipelines](#card-processors--pipelines) or the [demo fold
 from hanky import HankyPipeline
 
 
-# instantiate the hanky app
-hanky = HankyPipeline()
+# instantiate the hanky app, creating cards with the "basic" model
+hanky = HankyPipeline("basic")
 
 
-@hanky.card_processor("basic", expected_args=[], card_fields=[])
+@hanky.card_processor(expected_args=[], card_fields=[])
 def lowercase_card(card: dict):
     """Lower-case the text on every field of the card."""
     return {field: value.lower() for field, value in card.items()}
 
 
 # run the hanky cli application by running this python file, for example:
-#   python3 my_script.py pipe words.csv --model basic --into english::vocab
+#   python3 my_script.py pipe words.csv --into english::vocab
 hanky.run()
 
 ```
@@ -82,10 +82,10 @@ Ephemeral,Lasting A VERY Short Time
 We would run our new script like so
 
 ```sh
-python3 my_script.py pipe words.csv --model basic --into english::vocab
+python3 my_script.py pipe words.csv --into english::vocab
 ```
 
-Here we tell hanky to **pipe** each word in `words.csv` through our `card_processors`, **transforming** each line of the csv with the `lowercase_card`, before finally adding each card, of note type `basic`, into the anki deck `english::vocab`.
+Here we tell hanky to **pipe** each word in `words.csv` through our `card_processors`, **transforming** each line of the csv with the `lowercase_card`, before finally adding each card, of note type `basic` (the model we set on the pipeline), into the anki deck `english::vocab`. A single run can target a different model by passing `--model`.
 
 This would leave us with a **english::vocab** deck containing the following cards:
 
@@ -137,7 +137,7 @@ over the file). Useful if you want different config for different scripts:
 from hanky import HankyPipeline
 from hanky.config import Config
 
-hanky = HankyPipeline(config=Config(ALLOW_DUPLICATES=True))
+hanky = HankyPipeline("basic", config=Config(ALLOW_DUPLICATES=True))
 ```
 
 ## Card Processors & Pipelines
@@ -150,17 +150,20 @@ Multiple processors can be registered on a `HankyPipeline` app to create a pipel
 
 ### The processor contract
 
-A processor is registered with three things:
+Processors are model-agnostic: the Anki model/note-type is set once on the
+pipeline itself (`HankyPipeline("basic")`), and every card the pipeline adds is
+created with that model (unless overridden for a run with `--model`).
+
+A processor is registered with two things:
 
 ```python
-@hanky.card_processor(model, expected_args=[...], card_fields=[...])
+@hanky.card_processor(expected_args=[...], card_fields=[...])
 def my_processor(card: dict, **expected_args):
     ...
 ```
 
 | Part | Meaning |
 | --- | --- |
-| `model` | The Anki model/note-type name. The processor runs on every card of this model. |
 | `expected_args` | Names of CLI arguments the processor needs. They are passed in from the command line via `--args key=value` and arrive as keyword arguments. For example, you might have the same pipeline for different languages, so you would pass in `lang=german` or `lang=french`|
 | `card_fields` | Fields that **must already be present** on the card when this processor runs. Hanky checks this and raises a clear error if one is missing. It lets a processor declare what an *earlier* step must have produced. |
 
@@ -168,7 +171,7 @@ When hanky calls your processors, the first argument is always the `card`; a pla
 
 
 ```python
-@hanky.card_processor(model, expected_args=["lang"], card_fields=[...])
+@hanky.card_processor(expected_args=["lang"], card_fields=[...])
 def my_processor(card: dict, lang):
     ...
 ```
@@ -222,10 +225,10 @@ def scrape_wordreference(word: str, lang_pair: str) -> tuple[str, str]:
 def generate_neural_speech(utf_8_str: str, voice: str) -> bytes:
     ...
 
-hanky = HankyPipeline()
+hanky = HankyPipeline("lang-vocab")
 
 # Stage 1: requires `word` (this comes straight from the csv), produces `translation` + `example`.
-@hanky.card_processor("lang-vocab", expected_args=[], card_fields=["word"])
+@hanky.card_processor(expected_args=[], card_fields=["word"])
 def scrape_translation(card: dict):
     translation, example = scrape_wordreference(card["word"], "enfr")
     card["translation"] = translation
@@ -233,7 +236,7 @@ def scrape_translation(card: dict):
     return card
 
 # Stage 2: requires `translation` (from stage 1), attaches audio media.
-@hanky.card_processor("lang-vocab", expected_args=[], card_fields=["translation"])
+@hanky.card_processor(expected_args=[], card_fields=["translation"])
 def add_audio(card: dict):
     speech = generate_neural_speech(card["translation"], voice="Lea")
     audio = CardMedia(speech, ".mp3")
@@ -243,9 +246,9 @@ def add_audio(card: dict):
 hanky.run()
 ```
 
-Then we would run the script like normal. `python3 my_script.py pipe words.xlsx --model lang-vocab --into french::vocab`
+Then we would run the script like normal. `python3 my_script.py pipe words.xlsx --into french::vocab`
 
-> Note that we are no longer using a *basic* model. That means we are assuming that a model called *lang-vocab* has already been created in the anki ui. See the [Anki documentation for adding a note type](https://docs.ankiweb.net/editing.html#adding-a-note-type) to learn how this is done.
+> Note that this pipeline was created with the *lang-vocab* model rather than *basic*. That means we are assuming that a model called *lang-vocab* has already been created in the anki ui. See the [Anki documentation for adding a note type](https://docs.ankiweb.net/editing.html#adding-a-note-type) to learn how this is done.
 
 
 ### Attaching media
@@ -304,7 +307,7 @@ DICTIONARY = {
     # ...
 }
 
-hanky = HankyPipeline()
+hanky = HankyPipeline("basic")
 
 
 def random_word_cards(n):
@@ -313,7 +316,7 @@ def random_word_cards(n):
 
 
 # add 20 cards straight from the generator, with no file involved
-report = hanky.import_from_source(random_word_cards(20), "basic", "english::vocab")
+report = hanky.import_from_source(random_word_cards(20), "english::vocab")
 print(f"Added {report.added}, skipped {report.skipped}, failed {report.failed}.")
 ```
 
@@ -349,15 +352,20 @@ from simplest to most involved. Install their dependencies with
 Both the `hanky` command and your own scripts share the same interface:
 
 ```
-[hanky | python3 my_script.py] <operation> <file|dir> [pattern] --model MODEL [options]
+[hanky | python3 my_script.py] <operation> <file|dir> [pattern] [options]
 ```
 
+Cards are created with the model set on the pipeline (`HankyPipeline("basic")`);
+pass `-m/--model` to override it for a single run. The standalone `hanky`
+command has no script of its own, so it uses Anki's built-in `Basic` model
+unless you override it.
+
 **`pipe`** — pipe cards from a single file into a deck:
 
 ```
-hanky pipe [-h] -m MODEL [--into DECK] [--fail-fast] [--args K=V ...] file
+hanky pipe [-h] [-m MODEL] [--into DECK] [--fail-fast] [--args K=V ...] file
   file          File to load from (.csv, .json, or a registered extension).
-  -m, --model   Anki model/note-type name to create cards with. Required.
+  -m, --model   Override the Anki model/note-type name to create cards with.
   --into        Destination deck. Defaults to the filename without extension.
   --fail-fast   Stop and raise on the first card that can't be added, instead
                 of skipping it and reporting it at the end.
@@ -367,10 +375,10 @@ hanky pipe [-h] -m MODEL [--into DECK] [--fail-fast] [--args K=V ...] file
 **`pipe-dir`** — pipe many files from a directory, deriving deck names from paths:
 
 ```
-hanky pipe-dir [-h] -m MODEL [-r] [--fail-fast] [--args K=V ...] dir pattern
+hanky pipe-dir [-h] [-m MODEL] [-r] [--fail-fast] [--args K=V ...] dir pattern
   dir              Directory to load from.
   pattern          Glob selecting files, e.g. "*.csv".
-  -m, --model      Anki model/note-type name to create cards with. Required.
+  -m, --model      Override the Anki model/note-type name to create cards with.
   -r, --recursive  Also descend into sub-directories.
   --fail-fast      Stop and raise on the first card that can't be added, instead
                    of skipping it and reporting it at the end.
@@ -381,7 +389,7 @@ For example, to load every CSV under `french/` while building deck names from
 the folder structure:
 
 ```sh
-hanky pipe-dir "french/" "*.csv" --model basic -r
+hanky pipe-dir "french/" "*.csv" -r
 ```
 
 ```

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/pyproject.toml

@@ -16,7 +16,7 @@ classifiers = [
 ]
 
 keywords = ["anki"]
-version = "0.3.0.dev0"
+version = "0.3.0.dev1"
 
 dependencies = [
   "anki",

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/src/hanky/__main__.py

@@ -6,7 +6,8 @@ from hanky.errors import HankyError
 
 def main():
     try:
-        hanky = HankyPipeline()
+        # default to basic model
+        hanky = HankyPipeline("basic")
         hanky.run()
     except HankyError as e:
         print(f"error: {e}", file=sys.stderr)

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/src/hanky/cli.py

@@ -20,6 +20,17 @@ def _add_fail_fast(subparser):
     )
 
 
+def _add_model_override(subparser):
+    subparser.add_argument(
+        "-m",
+        "--model",
+        dest="model",
+        required=False,
+        default=None,
+        help="Override the name of the anki model to create cards with.",
+    )
+
+
 def _add_processor_args(subparser):
     subparser.add_argument(
         "--args",
@@ -45,13 +56,7 @@ def make_parser(has_card_processors=False):
         "pipe", help="Pipe card(s) from a file into an anki deck."
     )
     pipe.add_argument("file", help="Path of the file to load from")
-    pipe.add_argument(
-        "-m",
-        "--model",
-        dest="model",
-        required=True,
-        help="Name of the anki model to create cards with.",
-    )
+    _add_model_override(pipe)
     pipe.add_argument(
         "--into",
         dest="deck",
@@ -71,13 +76,7 @@ def make_parser(has_card_processors=False):
         "pattern",
         help="Glob pattern used to decide which files to load. For example, '*.csv'",
     )
-    pipe_dir.add_argument(
-        "-m",
-        "--model",
-        dest="model",
-        required=True,
-        help="Name of the anki model to create cards with.",
-    )
+    _add_model_override(pipe_dir)
     pipe_dir.add_argument(
         "-r",
         "--recursive",

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/src/hanky/hanky.py

@@ -14,7 +14,7 @@ from typing import (
 from anki.collection import Collection
 
 from hanky.anki_utils import add_card, add_deck, add_media, backup_collection
-from hanky.processors import CardProcessingException, ModelProcessor
+from hanky.processors import CardProcessingException, CardProcessor
 from hanky.cli import make_parser
 from hanky.config import Config
 from hanky.errors import (
@@ -35,31 +35,40 @@ class HankyPipeline:
     interactions with the anki collection and exposes a simplified interface
     for adding transformation logic. Optionally runnable as a CLI application.
 
+    Cards are added using the anki model/note type the pipeline was constructed
+    with (a single CLI run can override it via --model).
+
     Keeps track of 'card processor' functions/callables which enrich or
     transform their data before adding the card to the database.
 
     Keeps track of 'loader' functions which read possibly incomplete card data from files.
 
     Attributes:
-        config: dictionary representing configuration and kwargs arguments
-        processors: dictionary of anki model names mapped to user defined callables
+        config: the pipeline's Config object, lazy loaded if not provided
+        processors: list of user defined card processor callables, in registration order
         loaders: dictionary of file extensions mapped to a function which reads card data
     """
 
-    def __init__(self, config: Optional[Config] = None):
+    def __init__(self, model: str, *, config: Optional[Config] = None):
         """Initializes a HankyPipeline application object
 
         Note: if no config object is provided, hanky will try load from the default config location,
         before finally using the default configuration values if the file does not exist.
 
         Args:
+            model: the name of the anki model/note type to create cards with
             config: custom config object
         """
+        if not isinstance(model, str):
+            raise TypeError(
+                "'model' must be the name of an anki model/note type (a string)"
+            )
+
         self._config = config
 
         self._col: Optional[Collection] = None
-
-        self.processors: Dict[str, List[ModelProcessor]] = dict()
+        self._model = model
+        self.processors: List[CardProcessor] = list()
         self.loaders: Dict[str, Callable[[str], Iterator[dict]]] = dict()
         for ext, spec in DEFAULT_LOADERS.items():
             self.register_loader(
@@ -167,12 +176,11 @@ class HankyPipeline:
 
     def register_card_processor(
         self,
-        model_name: str,
         processor: Callable[[dict], dict],
         expected_args: List[str] = [],
         card_fields: List[str] = [],
     ) -> None:
-        """Adds a python callable to be called when adding a card of type model.
+        """Adds a python callable to be called as a processor during a pipeline run.
 
         The callable will be called with the first argument being the card
         data (a dictionary mapping field names to values) BEFORE the card
@@ -183,8 +191,7 @@ class HankyPipeline:
         order in which they were registered.
 
         Args:
-            model_name: the name of the card model
-            processor: the callable to apply to the cards of the given model type
+            processor: the callable to apply to each card
             expected_args: list of arguments expected by the callable
             card_fields: list of fields expected to be present in the card
                 when the callable is applied
@@ -192,15 +199,9 @@ class HankyPipeline:
         Returns:
             None
         """
-        if model_name not in self.processors:
-            self.processors[model_name] = []
-        self.processors[model_name].append(
-            ModelProcessor(processor, expected_args, card_fields)
-        )
+        self.processors.append(CardProcessor(processor, expected_args, card_fields))
 
-    def card_processor(
-        self, model: str, expected_args: List[str], card_fields: List[str]
-    ):
+    def card_processor(self, expected_args: List[str], card_fields: List[str]):
         """Decorator which automatically registers a card processor function
 
         A card processor takes a card (dictionary of field, value pairs) and any
@@ -212,14 +213,14 @@ class HankyPipeline:
             - perform a mathmatical operation then write back the answer as a string
             - set a field of a card which is currently missing
 
-        The decoracted function will be called every time a card of type model
-        is added. The first argument to the decorated function will always be
-        the card data as a dictionary of fields, value pairs.
+        The decorated function will be called on every card each time the pipeline
+        is run, whether via the CLI or the import_from_* methods. The first argument
+        to the decorated function will always be the card data as a dictionary of
+        fields, value pairs.
 
         The decorated function must return a dictionary.
 
         Args:
-            model_name: the name of the card model
             expected_args: list of named arguments expected by the card processor.
                 They will be passed in as key word arguments.
             card_fields: list of fields expected to be present in the card
@@ -230,18 +231,11 @@ class HankyPipeline:
         """
 
         def decorator(func):
-            self.register_card_processor(model, func, expected_args, card_fields)
+            self.register_card_processor(func, expected_args, card_fields)
             return func
 
         return decorator
 
-    def get_model_processors(self, model_name: str) -> List[ModelProcessor]:
-        """Get all card processors for a particular model"""
-        if model_name in self.processors:
-            return self.processors[model_name]
-
-        return []
-
     def get_loader(self, suffix) -> Callable:
         """Get the loader function for a particular file extension"""
         suffix = suffix.lower()
@@ -257,7 +251,6 @@ class HankyPipeline:
     def import_from_source(
         self,
         source: Iterable[Mapping],
-        model_name: str,
         deck_name: str,
         fail_fast: bool = False,
         **model_args,
@@ -271,7 +264,6 @@ class HankyPipeline:
         Args:
             source: any iterable yielding dictionaries (mappings) of card
                 field names to values
-            model_name: The anki model/card type of the cards
             deck_name: the name of the destination deck
             fail_fast: raise on the first bad card instead of collecting it
             **model_args: arguments to provide to the card processor functions
@@ -280,16 +272,15 @@ class HankyPipeline:
             A :class:`LoadReport` describing what was added, skipped and failed.
 
         Raises:
-            ModelNotFoundError: the model does not exist in the collection
+            ModelNotFoundError: the pipeline's model does not exist in the collection
             Exception: if ``fail_fast`` is set, whatever a bad card raised
         """
-        transformers = self.get_model_processors(model_name)
 
         with self.session() as col:
-            model = col.models.by_name(model_name)
+            model = col.models.by_name(self._model)
             if not model:
                 raise ModelNotFoundError(
-                    f"Model '{model_name}' does not exist in your anki collection. Ensure it has been added before using it with hanky."
+                    f"Model '{self._model}' does not exist in your anki collection. Ensure it has been added before using it with hanky."
                 )
 
             add_deck(col, deck_name)
@@ -301,12 +292,12 @@ class HankyPipeline:
                 try:
                     if not isinstance(item, Mapping):
                         raise ValueError(
-                            f"Card source for model '{model_name}' yielded a "
+                            f"Card source for model '{self._model}' yielded a "
                             f"{type(item).__name__}, expected a dictionary (mapping)."
                         )
                     card = dict(item)
                     media: List[CardMedia] = []
-                    for t in transformers:
+                    for t in self.processors:
                         card, new_media = t(card, **model_args)
                         media += new_media
 
@@ -319,7 +310,7 @@ class HankyPipeline:
                     if add_card(
                         col,
                         deck_name,
-                        model_name,
+                        self._model,
                         allow_duplicates=self.config.ALLOW_DUPLICATES,
                         **card,
                     ):
@@ -329,7 +320,7 @@ class HankyPipeline:
                 except Exception as e:
                     # inject model info into exception which processor doesn't know
                     if isinstance(e, CardProcessingException):
-                        e.model = model_name
+                        e.model = self._model
                     if fail_fast:
                         raise
                     errors.append(CardError(card=item, error=str(e)))
@@ -339,7 +330,6 @@ class HankyPipeline:
     def import_from_file(
         self,
         fpath: str,
-        model_name: str,
         deck_name: Optional[str] = None,
         fail_fast: bool = False,
         **model_args,
@@ -351,7 +341,6 @@ class HankyPipeline:
 
         Args:
             fpath: the path to the file
-            model_name: The anki model/card type of the cards in the file
             deck_name: Optionally the name of the deck. Defaults to the
                 filename without its extension.
             fail_fast: raise on the first bad card instead of collecting it
@@ -368,13 +357,12 @@ class HankyPipeline:
 
         source = self.get_loader(path.suffix)(str(path))
         report = self.import_from_source(
-            source, model_name, deck_name, fail_fast=fail_fast, **model_args
+            source, deck_name, fail_fast=fail_fast, **model_args
         )
         return report.with_source(str(path))
 
     def import_from_dir(
         self,
-        model: str,
         root_dir: str,
         glob_pattern: str,
         recursive=False,
@@ -402,7 +390,6 @@ class HankyPipeline:
         french::grammar::passe_compose
 
         Args:
-            model_name: The anki model/card type of the cards which will be loaded
             root_dir: The root directory in which to find the files
             glob_pattern: A glob pattern such as '*.csv' to match the desired files
             recursive: whether or not to descend into sub directories, defaults to false
@@ -448,7 +435,6 @@ class HankyPipeline:
 
                     report += self.import_from_file(
                         str(abs_path),
-                        model,
                         deck_name=full_deck,
                         fail_fast=fail_fast,
                         **model_args,
@@ -488,12 +474,15 @@ def _run_app(app: HankyPipeline, args: Optional[Sequence[str]] = None):
     except AttributeError:
         pass
 
+    # TODO: shouldn't really mutate _model like this
+    if parsed_args.model is not None:
+        app._model = parsed_args.model
+
     report = LoadReport()
     if parsed_args.operation == "pipe":
         print(f"Loading into deck {parsed_args.deck} from file {parsed_args.file}")
         report = app.import_from_file(
             parsed_args.file,
-            parsed_args.model,
             deck_name=parsed_args.deck,
             fail_fast=parsed_args.fail_fast,
             **model_args,
@@ -502,7 +491,6 @@ def _run_app(app: HankyPipeline, args: Optional[Sequence[str]] = None):
     elif parsed_args.operation == "pipe-dir":
         print(f"Loading from dirrectory {parsed_args.dir}")
         report = app.import_from_dir(
-            parsed_args.model,
             parsed_args.dir,
             parsed_args.pattern,
             parsed_args.is_rec,

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/src/hanky/processors.py

@@ -30,7 +30,7 @@ class CardProcessingException(Exception):
         )
 
 
-class ModelProcessor:
+class CardProcessor:
     """The wrapper for user defined functions which processes cards.
 
     Wraps a python callable which takes a dictionary representing an anki card,
@@ -49,7 +49,7 @@ class ModelProcessor:
         expected_args: List[str],
         card_fields: List[str],
     ):
-        """Initializes a model processor
+        """Initializes a card processor
 
         Args:
             func: the user defined callable which processes each card

{hanky-0.3.0.dev0 → hanky-0.3.0.dev1}/uv.lock

@@ -398,7 +398,7 @@ wheels = [
 
 [[package]]
 name = "hanky"
-version = "0.3.0.dev0"
+version = "0.3.0.dev1"
 source = { editable = "." }
 dependencies = [
     { name = "anki" },