hexdoc.cli.utils

128class Typer:
129    def __init__(
130        self,
131        *,
132        name: Optional[str] = Default(None),
133        cls: Optional[Type[TyperGroup]] = Default(None),
134        invoke_without_command: bool = Default(False),
135        no_args_is_help: bool = Default(False),
136        subcommand_metavar: Optional[str] = Default(None),
137        chain: bool = Default(False),
138        result_callback: Optional[Callable[..., Any]] = Default(None),
139        # Command
140        context_settings: Optional[Dict[Any, Any]] = Default(None),
141        callback: Optional[Callable[..., Any]] = Default(None),
142        help: Optional[str] = Default(None),
143        epilog: Optional[str] = Default(None),
144        short_help: Optional[str] = Default(None),
145        options_metavar: str = Default("[OPTIONS]"),
146        add_help_option: bool = Default(True),
147        hidden: bool = Default(False),
148        deprecated: bool = Default(False),
149        add_completion: bool = True,
150        # Rich settings
151        rich_markup_mode: MarkupMode = Default(DEFAULT_MARKUP_MODE),
152        rich_help_panel: Union[str, None] = Default(None),
153        pretty_exceptions_enable: bool = True,
154        pretty_exceptions_show_locals: bool = True,
155        pretty_exceptions_short: bool = True,
156    ):
157        self._add_completion = add_completion
158        self.rich_markup_mode: MarkupMode = rich_markup_mode
159        self.rich_help_panel = rich_help_panel
160        self.pretty_exceptions_enable = pretty_exceptions_enable
161        self.pretty_exceptions_show_locals = pretty_exceptions_show_locals
162        self.pretty_exceptions_short = pretty_exceptions_short
163        self.info = TyperInfo(
164            name=name,
165            cls=cls,
166            invoke_without_command=invoke_without_command,
167            no_args_is_help=no_args_is_help,
168            subcommand_metavar=subcommand_metavar,
169            chain=chain,
170            result_callback=result_callback,
171            context_settings=context_settings,
172            callback=callback,
173            help=help,
174            epilog=epilog,
175            short_help=short_help,
176            options_metavar=options_metavar,
177            add_help_option=add_help_option,
178            hidden=hidden,
179            deprecated=deprecated,
180        )
181        self.registered_groups: List[TyperInfo] = []
182        self.registered_commands: List[CommandInfo] = []
183        self.registered_callback: Optional[TyperInfo] = None
184
185    def callback(
186        self,
187        *,
188        cls: Optional[Type[TyperGroup]] = Default(None),
189        invoke_without_command: bool = Default(False),
190        no_args_is_help: bool = Default(False),
191        subcommand_metavar: Optional[str] = Default(None),
192        chain: bool = Default(False),
193        result_callback: Optional[Callable[..., Any]] = Default(None),
194        # Command
195        context_settings: Optional[Dict[Any, Any]] = Default(None),
196        help: Optional[str] = Default(None),
197        epilog: Optional[str] = Default(None),
198        short_help: Optional[str] = Default(None),
199        options_metavar: str = Default("[OPTIONS]"),
200        add_help_option: bool = Default(True),
201        hidden: bool = Default(False),
202        deprecated: bool = Default(False),
203        # Rich settings
204        rich_help_panel: Union[str, None] = Default(None),
205    ) -> Callable[[CommandFunctionType], CommandFunctionType]:
206        def decorator(f: CommandFunctionType) -> CommandFunctionType:
207            self.registered_callback = TyperInfo(
208                cls=cls,
209                invoke_without_command=invoke_without_command,
210                no_args_is_help=no_args_is_help,
211                subcommand_metavar=subcommand_metavar,
212                chain=chain,
213                result_callback=result_callback,
214                context_settings=context_settings,
215                callback=f,
216                help=help,
217                epilog=epilog,
218                short_help=short_help,
219                options_metavar=options_metavar,
220                add_help_option=add_help_option,
221                hidden=hidden,
222                deprecated=deprecated,
223                rich_help_panel=rich_help_panel,
224            )
225            return f
226
227        return decorator
228
229    def command(
230        self,
231        name: Optional[str] = None,
232        *,
233        cls: Optional[Type[TyperCommand]] = None,
234        context_settings: Optional[Dict[Any, Any]] = None,
235        help: Optional[str] = None,
236        epilog: Optional[str] = None,
237        short_help: Optional[str] = None,
238        options_metavar: str = "[OPTIONS]",
239        add_help_option: bool = True,
240        no_args_is_help: bool = False,
241        hidden: bool = False,
242        deprecated: bool = False,
243        # Rich settings
244        rich_help_panel: Union[str, None] = Default(None),
245    ) -> Callable[[CommandFunctionType], CommandFunctionType]:
246        if cls is None:
247            cls = TyperCommand
248
249        def decorator(f: CommandFunctionType) -> CommandFunctionType:
250            self.registered_commands.append(
251                CommandInfo(
252                    name=name,
253                    cls=cls,
254                    context_settings=context_settings,
255                    callback=f,
256                    help=help,
257                    epilog=epilog,
258                    short_help=short_help,
259                    options_metavar=options_metavar,
260                    add_help_option=add_help_option,
261                    no_args_is_help=no_args_is_help,
262                    hidden=hidden,
263                    deprecated=deprecated,
264                    # Rich settings
265                    rich_help_panel=rich_help_panel,
266                )
267            )
268            return f
269
270        return decorator
271
272    def add_typer(
273        self,
274        typer_instance: "Typer",
275        *,
276        name: Optional[str] = Default(None),
277        cls: Optional[Type[TyperGroup]] = Default(None),
278        invoke_without_command: bool = Default(False),
279        no_args_is_help: bool = Default(False),
280        subcommand_metavar: Optional[str] = Default(None),
281        chain: bool = Default(False),
282        result_callback: Optional[Callable[..., Any]] = Default(None),
283        # Command
284        context_settings: Optional[Dict[Any, Any]] = Default(None),
285        callback: Optional[Callable[..., Any]] = Default(None),
286        help: Optional[str] = Default(None),
287        epilog: Optional[str] = Default(None),
288        short_help: Optional[str] = Default(None),
289        options_metavar: str = Default("[OPTIONS]"),
290        add_help_option: bool = Default(True),
291        hidden: bool = Default(False),
292        deprecated: bool = Default(False),
293        # Rich settings
294        rich_help_panel: Union[str, None] = Default(None),
295    ) -> None:
296        self.registered_groups.append(
297            TyperInfo(
298                typer_instance,
299                name=name,
300                cls=cls,
301                invoke_without_command=invoke_without_command,
302                no_args_is_help=no_args_is_help,
303                subcommand_metavar=subcommand_metavar,
304                chain=chain,
305                result_callback=result_callback,
306                context_settings=context_settings,
307                callback=callback,
308                help=help,
309                epilog=epilog,
310                short_help=short_help,
311                options_metavar=options_metavar,
312                add_help_option=add_help_option,
313                hidden=hidden,
314                deprecated=deprecated,
315                rich_help_panel=rich_help_panel,
316            )
317        )
318
319    def __call__(self, *args: Any, **kwargs: Any) -> Any:
320        if sys.excepthook != except_hook:
321            sys.excepthook = except_hook
322        try:
323            return get_command(self)(*args, **kwargs)
324        except Exception as e:
325            # Set a custom attribute to tell the hook to show nice exceptions for user
326            # code. An alternative/first implementation was a custom exception with
327            # raise custom_exc from e
328            # but that means the last error shown is the custom exception, not the
329            # actual error. This trick improves developer experience by showing the
330            # actual error last.
331            setattr(
332                e,
333                _typer_developer_exception_attr_name,
334                DeveloperExceptionConfig(
335                    pretty_exceptions_enable=self.pretty_exceptions_enable,
336                    pretty_exceptions_show_locals=self.pretty_exceptions_show_locals,
337                    pretty_exceptions_short=self.pretty_exceptions_short,
338                ),
339            )
340            raise e

117def init_context(
118    *,
119    book_id: ResourceLocation,
120    book_data: dict[str, Any],
121    pm: PluginManager,
122    loader: ModResourceLoader,
123    i18n: I18n,
124    all_metadata: dict[str, HexdocMetadata],
125):
126    props = loader.props
127
128    context = dict[str, Any]()
129
130    for item in [
131        props,
132        pm,
133        loader,
134        i18n,
135        TextureContext(
136            textures=load_metadata_textures(all_metadata),
137            allowed_missing_textures=props.textures.missing,
138        ),
139        FormattingContext(
140            book_id=book_id,
141            macros=DEFAULT_MACROS | book_data.get("macros", {}) | props.macros,
142        ),
143        BookContext(
144            modid=props.modid,
145            book_id=book_id,
146            spoilered_advancements=Tag.SPOILERED_ADVANCEMENTS.load(
147                loader
148            ).value_ids_set,
149            all_metadata=all_metadata,
150        ),
151    ]:
152        item.add_to_context(context)
153
154    for item in pm.update_context(context):
155        item.add_to_context(context)
156
157    return context

50def load_common_data(
51    props_file: Path,
52    branch: str,
53    *,
54    book: bool = False,
55) -> tuple[Properties, PluginManager, BookPlugin[Any], ModPlugin]:
56    props = Properties.load(props_file)
57    pm = PluginManager(branch, props)
58
59    book_plugin = pm.book_plugin(props.book_type)
60    mod_plugin = pm.mod_plugin(props.modid, book=book)
61
62    header = get_header(props, pm, mod_plugin)
63    logger.info(f"Loading hexdoc.\n{indent(header, '  ')}")
64
65    minecraft_version = MinecraftVersion.MINECRAFT_VERSION = pm.minecraft_version()
66    if minecraft_version is None:
67        logger.warning(
68            "No plugins implement minecraft_version. All versions may be used."
69        )
70
71    return props, pm, book_plugin, mod_plugin

 74def render_textures_and_export_metadata(
 75    loader: ModResourceLoader,
 76    asset_loader: HexdocAssetLoader,
 77):
 78    all_metadata = loader.load_metadata(model_type=HexdocMetadata)
 79
 80    all_lookups = load_metadata_textures(all_metadata)
 81    image_textures = {
 82        id: texture
 83        for texture_type in [PNGTexture, AnimatedTexture]
 84        for id, texture in texture_type.get_lookup(all_lookups).items()
 85    }
 86
 87    internal_lookups = TextureLookups[Texture](dict)
 88    if loader.props.textures.enabled:
 89        logger.info(f"Loading and rendering textures to {asset_loader.render_dir}.")
 90        for id, texture in asset_loader.load_and_render_internal_textures(
 91            image_textures
 92        ):
 93            texture.insert_texture(internal_lookups, id)
 94
 95    # this mod's metadata
 96    metadata = HexdocMetadata(
 97        book_url=asset_loader.site_url / loader.props.default_lang,
 98        asset_url=loader.props.env.asset_url,
 99        textures=internal_lookups,
100    )
101
102    loader.export(
103        metadata.path(loader.props.modid),
104        metadata.model_dump_json(
105            by_alias=True,
106            warnings=False,
107            exclude_defaults=True,
108            round_trip=True,
109        ),
110        cache=True,
111    )
112
113    return all_metadata | {loader.props.modid: metadata}