hexdoc.cli.utils

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