hexdoc.cli.utils

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