Saravanan666/pypi-org huggingface dataset:
Package: mkdocs-labeled-user-defined-values
mkdocs-labeled-user-defined-valuesThis is a plugin for a MkDocs which allows pages to have user defined input values.The difference with the original mkdocs-user-defined-values is the capability to categorize keywords.SetupInstall the plugin using pip:pip install mkdocs-labeled-user-defined-valuesActivate the plugin inmkdocs.yml:plugins:-search-user-defined-values:input-placeholder:"{{{user-defined-values}}}"keywords:cat1:YOUR_AWS_REGION:placeholder:e.g. ap-southeast-2YOUR_AWS_ACCOUNT_ID:placeholder:e.g. 12355224536cat2:ANOTHER_KEYWORD:label:any label that I want to displayplaceholder:e.g. any placeholder that I want to displayNote:If you have nopluginsentry in your config file yet, you'll likely also want to add thesearchplugin. MkDocs enables it by default if there is nopluginsentry set, but now you have to enable it explicitly.More information about plugins in theMkDocs documentation.Configkeywords- This is a list of keywords which you want to allow a user to modify.input-placeholder- This is a placeholder where you want the plugin to generate the form for user to provide dynamic values for each keyword. Default value is{{{user-defined-values}}}.
Please note that appart fromkeywordsandcategory names(cat1andcat2in the above example), most of the parameters are optional.UsageProvide a list ofkeywordsyou want a user to provide dynamically.Place{{{user-defined-values}}}in your page or template where you want to generate the form for user to provide dynamic values.You can replacecategory namesby any name you desire.See AlsoMore information about templateshere.More information about blockshere.
Package: mkdocs-latest-git-tag-plugin
MkDocs Plugin :latest-git-tagThis is a simpleMkDocsplugin that just gets the
most recentTagfrom the local Git repository and makes it available as a
markdown tag in the template.The idea behind this is that GitHub uses theTagto name the release and,
therefore we can use it to display the version of the documentation that
corresponds to the release.The Tag is just returned as a string with no formatting applied. If none is
found, it returns "No Tags found"There is aDemo SiteInstallationInstall the package with pip:pipinstallmkdocs-latest-git-tag-pluginor, if you are usingPoetry:poetryaddmkdocs-latest-git-tag-plugin--groupdevUsageActivate the plugin in yourmkdocs.yml:plugins:-latest-git-tagIf you have nopluginsentry in your config file yet, you'll likely also
want to add thesearchplugin. MkDocs enables it by default if  here is nopluginsentry set.Then, in your template, you can use the{{ latest_git_tag }}variable:# My ProjectVersion: {{ latest_git_tag }}The spaces around the tag are optional and it is case insensitive.ConfigurationAt this time there are no configuration options.LicenseThis is released under the MIT License. See the bundled LICENSE file for more
details.TODOAdd tests
Package: mkdocs-latest-release-plugin
mkdocs_latest_release_pluginPlugin for MKDocs to inject a Git Tag into the markdown. The primary purpose is to allow an MKDocs site, in the same repository as the application in GitHub, to display the latest released version, based on the git tags.Origin and PurposeThis plugin was specifically created to support GitHub projects using GitHub Pages and mkdocs to publish documentation which also use tags to mark releases. Case in point is authoring Jenkins shared libraries and associated documentation. The shared libraries are cloned by consumers using a the repository source and a git tag to specify the version. Documentation for the shared library lives within the same repository, so ensuring documentation is updated can be part of the Pull Request/review process, however not all merges to master are released. It was initially useful to refer to the latest release version in the documentation, but this quickly went out of date, as not all merges to master were released, so it was not practical to maintain this manually, and in generally nothing should be maintained manually that doesn't have to be. Hence the need for this plugin to MKDocs which is used in the automated build and release process for our Jenkins shared library code.Installpip install mkdocs_latest_release_pluginUsageEnable the plugin inmkdocs.ymlplugins:-search-git-latest-releaseAdd{{ git_latest_release }}anywhere in the markdown where you want to refer to the latest release tag. Release tags are presumed to be semantic version tags, therefore matching the regex\d+\.\d+\.\d+.
Package: mkdocs-leanix-plugin
MkDocs LeanIX PluginThis is a plugin forMkDocsto display data fromLeanIX.SetupInstall the plugin using pip:pip install mkdocs-leanix-pluginActivate the plugin inmkdocs.yml:plugins:-leanixNote:If you have nopluginsentry in your config file yet, you'll likely also want to add thesearchplugin. MkDocs enables it by default if there is nopluginsentry set, but now you have to enable it explicitly.More information about plugins in theMkDocs documentation.Configurationapi_token- The API tokenbase_url- Base URL of your LeanIX instance. Can behttps://yourorganization.leanix.netmaterial[optional] - Set this totrueif the material design template should be used. This requires thepymdownx.tabbedextension to be enabledAlternatively to theapi_tokenin themkdocs.ymla environment variable calledLEANIX_API_TOKENcan be set. This is likely the way in CI/CD scenarios.Workspace information (name and id) is retrived from the JWT token.Sampleplugins- leanix:api_token:asdfsa23kjlsadflkjsalkjf3# or LEANIX_API_TOKEN environment variablebase_url:https://yourcompany.leanix.net/workspace_name:testUsageSimply create a code block of the typeleanix-factsheetand insert the GUID of the factsheet to be shown:Sample```leanix-factsheetd3bdeca8-8f79-4ee9-af4b-e390accf9f3d```CustomizationOwn templates can be used. Add the path to the template after the factsheet GUID. The template must be inside the docs directory.```leanix-factsheetd3bdeca8-8f79-4ee9-af4b-e390accf9f3dtemplates/custom_factsheet.jinja2```Get some inspiration of thepacked templates. A factsheet object will be provided asfsand can be printed out with{{ fs }}. Two helper functions are provided:get_user(userid)- Gets friendly username from LeanIX and creates a Markdown mailto-link.get_font_color(backgroundColor)- Gets a black or white CSS color from a provided CSS background color. Can be used to ensure enough contrast between text and background color.ScreenshotsOverviewDocumentsSubscriptionsLifecycle
Package: mkdocs-licenseinfo
mkdocs_licenseinfomkdocs extension to visualise package dependencies license informationIntroductionContributingTo see the contribution guidelines, seedocs/source/developing/index.md.Setting up for developmentCreate a virtual environment.
Install the package usingpip install -e .[dev]Then add code to the package as appropriate - submodules can be created undersrc/mkdocs_licenseinfoTests can be added to the tests folderCIThere are a set of CI checks:lint:nox -t linttest:nox -t testbuild:nox -t buildspecific subfolders can be passed to the test tag in nox:nox -t test -- <subfolder1> <subfolder2>VersioningIt is important to track and version code, and to aid that with the python packages and models,setuptools_scmis used.
This links the version reported at__version__to the git tag (+ commit hash if appropriate), to reduce the amount of
places that need editing when changing versions.For describing versions we are using semantic versioning<major>.<minor>.<patch>. Increment the:<major>version when you make incompatible API changes,<minor>version when you add functionality in a backwards-compatible manner, and<patch>version when you make backwards-compatible bug fixes.There are also codes for pre-releases and other descriptions (seehttps://semver.org/)To create a version, usegit tag <major>.<minor>.<patch>and then make sure to push that tag withgit push origin <major>.<minor>.<patch>,
or an equivalent tagging tool (e.g. Github releases).TODOAdd sbom file links for serving (::license-embed)Repo created from nskit.recipes.python.package:PackageRecipe (version 0.0.post1.dev15+ga59b052.d20231223) usingnskit.
Package: mkdocs-linkcheck
Link Checker for Mkdocs-based static generated sitesThis project was designed to help validate links associated with markdown-based, staticly generated website -- especially those published viaMkdocs. It is a fork oflinkcheckmd, and offers many enhancements over its predecessor. This project has the following features:Scan and validate links for over 10,000 markdown files per secondCheck local (relative) and remote linksRecurse through an entire documentation treeCheck remote links using a synchronous or asynchronous processExclude links from being checkedOutput useful summary reports to help you track down and fix broken linksWhile development focused on testing mkdocs-generated sites, this project should in theory work with any markdown-based website generator.InstallFor latest release:%python-mpipinstallmkdocs-linkcheckOr, for latest development version.%gitclonehttps://github.com/byrnereese/linkchecker-mkdocs
%pipinstall-elinkchecker-mkdocsUsageThe static site generator does NOT have to be running for these tests. This program looks at the Markdown .md files directly.If any local or remote links are determined to be missing, the following happens:the file containing the bad link and the link is printed to "stdout"the program will exit with code 22 instead of 0 after all files are checkedThe bad links are printed to stdout since the normal operation of this program is to check for errors.
Due to the fast, concurrent checking and numerous pages checked, there may be diagnostics printed to stderr.
That way library error messages can be kept separate from the missing page locations printed on stdout.The examples assume webpage Markdown files have top-level directory ~/docs.Python codeimportmkdocs-linkcheckaslclc.check_links("~/docs")Command-lineThis program may be invoked by either:mkdocs-linkcheckorpython-mmkdocs-linkcheckCommand link argumentsUsagemkdocs-linkcheck [-h] [-ext EXT] [-m {get,head}] [-v] [--sync] [--exclude EXCLUDE] [-local] [-r] path [domain]Positional arguments:path- path to Markdown filesdomain- check only links to this domain (say github.com without https etc.)Optional arguments:-h,--help- show a help message and exit-ext <str>- file extension to scan-m {get,head},--method {get,head}- The HTTP method to use when testing remote links. The "head" method is faster but gives false positives. The "get" method is reliable but slower--sync- enable synchronous checking of remote links, or do not use asyncio--exclude str- a pattern for a file or path to exclude from being checked; use this argument multiple times to exclude multiple files. Regular expressions are ok.-local- check local files only-r,--recurse- recurse through all directories under path-vor--verbose-prints the URLs as they are checkedGit precommitSee./examples/pre-commitscript for aGit hook pre-commitPython script.Tox and CIThis program can also be used as a check for bad links during continuous integration testing or when usingtox.
Package: mkdocs-link-marker
mkdocs-link-markerMkDocs plugin for marking external or mail links in your documentation.SetupInstall the plugin:pipinstallmkdocs-link-markerAdd the plugin to yourmkdocs.ymlplugins:-search-link-markerUsageRun the build!Optionsenable_external_linkWhether to mark external links with the according icon.
Default: Trueicon_external_linkChange the default icon for marking external links.
Default: ⧉enable_mailWhether to mark mail links with the according icon.
Default: Trueicon_mailChange the default icon for marking mail links.
Default: ✉
Package: mkdocs-link-preview-plugin
mkdocs-obsidian-support-pluginPlugin formkdocs-materialprovide external link preview.pip install beautifulsoup4
pip install mkdocs-link-preview-pluginIt requires beautifulsoup4 for crawling the open grapth protocol metadata.UsageActivate the plugin in mkdocs.ymlplugins:-link-previewextra_css:-path/to/link-preview.cssFeatureIt converts below codeblock syntax to preview-html based onThe Open Graph Protocol.```preview
https://github.com/ndy2/mkdocs-link-preview-plugin
```rendered aswith default css configuration.super simple demo link -https://ndy2.github.io/mkdocs-link-preview-plugin/Inspired byhttps://github.com/dhamaniasad/obsidian-rich-links
Package: mkdocs-live-edit-plugin
mkdocs-live-edit-pluginAn MkDocs plugin that allows editing pages directly from the browser.Things you can do with this plugin when running viamkdocs serve:Editing a page's Markdown source from the page itself.Renaming a page's filenameDeleting a pageSome basic editor shortcuts available while editing:Ctrl+B/Cmd+B toggles your selection to beBoldCtrl+I/Cmd+I toggles your selection to beItalicAlt+S/Opt+S toggles your selection to beStrikethroughCtrl+S/Cmd+S to save your changesIf you like this plugin, you'll probably also likemkdocs-categories-pluginandmkdocs-alias-plugin.InstallationUsing Python 3.10 or greater, install the package using pip:pipinstallmkdocs-live-edit-pluginThen add the following entry to the plugins section of yourmkdocs.ymlfile:plugins:
  - live-editUsageIf for any reason you want to override the port that the Live Edit WebSocket is operating on, you can do so by setting thewebsockets_portoption for thelive-editplugin, like so:plugins:
  - live-edit:
      websockets_port: 9999 # or any other port you wantTODOCreating new pages (not sure how picking directories would work)Moving pages (also not sure about handling directories here)Integration withmkdocs-categories-pluginIntegration withmkdocs-alias-pluginHow Does it Work?The short answer:WebSocketshandle client-server communication, while MkDocs handles reloading when files change.The Longer AnswerOnce installed, when running your local live-reload server, the plugin registers a separate WebSockets server that runs on a specified port. Once your wiki is built, a WebSockets client is installed in your browser, allowing for asynchronous communication between the two.When you edit the contents of a file, they are sent to the server via WebSockets where the plugin writes the contents to disk. Here, MkDocs picks up on the change and sends a reload signal back to the browser -- this is the same live-reload mechanism that picks up on changes you make via a text editor.A similar mechanism is in place for other operations like renaming and deleting.Changelog0.1.5Bug fix: fixes an issue where the WebSocket connection would host on localhost over IPv6. See#3for context.0.1.4Bug fix: Improved WebSocket connectivity and error handling. Updated the documentation to match.0.1.3Bug fix: The WebSocket connection now honors the hostname as supplied by the browser inwindow.location.hostname.0.1.2Bug fix: include missing data files0.1.1Bug fix: include non-python files in the package0.1.0Initial release with editing, renaming, and deletion logic in place.
Package: mkdocs-macros-adr-summary
mkdocs-macros-adr-summaryThis is a macro plugin to generates summaries from a list of a ADR documents in a directory.Examples and documentation can be foundhereThe package should be stable enough for daily use. I'll release 1.0.0, and switch to semantic version,
as soon as support for MADR version 2 has been implemented. Until that breaking changes can be introduced
and will be documented in the GitHub release description.Quick startEnable the plugin inmkdocs.ymlplugins:-macros:module_name:mkdocs_macros_adr_summaryCreate a markdown page in your mkdocs website and use theadr_summarymacro providing
the path containing your ADR files relative to themkdocs.ymlfile.{{ adr_summary(adr_path="docs/adr", adr_style="nygard") }}adr_stylecan benygardorMADR3More customizationThe page output is generated using a jinja template, but you can provide a custom one. The file path
must still be relative to themkdocs.ymlfile.{{ adr_summary(adr_path="docs/adr", adr_style="MADR3", template_file="other.jinja") }}The default template is:## Document list{% for d in documents %}*[{{ d.title }}]({{ d.filename }})*`{{ d.date.strftime('%d-%m-%Y') }}`*`{{ d.file_path }}`{% if d.statuses %}*Statuses:
        {% for status in d.statuses %}*{{ status }}
        {% endfor %}
    {% endif %}
{% endfor %}Thedocumentsvariable in the jinja template is a Sequence ofADRDocumentmodels:@dataclassclassADRDocument:file_path:strtitle:Optional[str]=Nonedate:Optional[date]=Nonestasdetus:Optional[str]=Nonestatuses:Sequence[str]=tuple()deciders:Optional[str]=Noneconsulted:Optional[str]=Noneinformed:Optional[str]=NoneThere are some differences in what metadata is available when using different formats:NygardMADR3MADR2file_path✅︎✅︎✅︎title✅︎✅︎✅︎date✅︎✅︎TODOstatus⚠✅︎TODOstatuses✅︎⚠TODOdeciders❌✅︎TODOconsulted❌✅︎TODOinformed❌✅︎TODONygard formatstatusis the last itemstatuses. (I don't believe we should use multiple
statuses, howeveradr-toolsallows it)deciders,consultedandinformedare not supported by the formatMADR3I wasn't able to find an automated tool supporting superseding documents.
By looking at the template it looks like there's a single status.statuseswill return a list with a single status.Supported ADR formatsThe supported ADR formats are:nygardformat, it is recommended to useadr-toolsto manage the directoryMADRversion 3Support forMADRversion 2 will be added in a future version.Commands for developmentAll the common commands used during development can be run using make targets:make dev-dependencies: Install dev requirementsmake update-dependencies: Update dev requirementsmake test: Run test suitemake check: Run tests, code style and lint checksmake fix: Run code style and lint automatic fixes (where possible)make docs: Render the mkdocs website locally
Package: mkdocs-macros-includex
includexUseincludextoincludeanythingfrom any file into your markdown documentation.Installationpipinstallmkdocs-macrosmkdocs-macros-includexUsageincludexcan be configured as aplugletfor mkdocs-macros in themkdocs.ymlconfiguration file:plugins:-search-macros:modules:['includex']Then you can use it to dynamically include file content in your documentation### VersioningThe version number is defined in the`pyproject.toml`file:

{{ includex("pyproject.toml", start_match="[tool.hatch.version]", code=True, lines=2, caption=True) }}which would be rendered asVersioningThe version number is defined in thepyproject.tomlfile:[tool.hatch.version]path="includex.py"pyproject.toml, lines 14-15Comparison to other toolssnippets (pymdown-extensions)tl;drusesnippetsif you want to recursively include contentuseincludexif you want to include content within macrosuseincludexif you want to include sections without special markersThe main use case this solves oversnippetsis that it includes partial content (i.e. a section or block) from a file as-is (i.e. without the need for special markers).Snippets partially supports this now since v9.6 added support to include sections by lines.^snippet-linesFurther, v9.7 added to support to sections by name, given that they are marked as such using a special marker comment.^snippet-sectionsWhat includex does additionally is to match the start and end of blocks and include them without the need for any markers or line numbers.
While this makes the documentation more prone to break, e.g., when the line that is being matched is changed in a way that it no longer matches, it supports some additional use-cases and requires less custom syntax.Snippetsis implemented as a preprocessor, whileincludexis implemented as amkdocs-macrospluglet. This means that snippets are evaluated earlier thanincludexand prohibitssnippetsto work with other macros, like this:{%forfileinget_files("docs/")%}{{includex(file)}}{%endfor%}However, sections included usingincludexare not evaluated themselves, soincludexcannot be nested (yet). If you need nested includes, usesnippetsinstead.
Package: mkdocs-macros-test-ntno
Test pluglet for mkdocs-macrosWhat it isThis is a testplugletfor mkdocs-macros.
Its purpose is to serve as a template
for pluglets.It exports three macros, which can be used in markdown pages, and aren't particularly
interesting:test_fn(x:float): an arithmetic expression.say_hello(s:str): displays Hello followed by the string, in italics.test_fn2(s:str): same assay_hello()but does it slightly differentlyFor example, you could write:He said {{ say_hello('Joe') }}.Which will be translated into HTML as:He said <i>Hello Joe</i>How to install itDirectly from pypi:pip install mkdocs-macros-testOr directly from the github repository: download
the package and run:python setup.py installHow to call it from an MkDocs projectIn the config (mkdocs.yml) file:plugins:-search-macros:modules:['mkdocs_test`]Noteshttps://github.com/fralau/mkdocs_macros_pluginquestion - can this plugin be used to change the jinja2 environment that mkdocs uses?use case:
i would like to be able to install a jinja2 extension and then use that extension in my custom mkdocs themein particular:https://github.com/danielchatfield/jinja2_markdownhttps://github.com/fralau/mkdocs_macros_plugin/blob/master/mkdocs_macros/plugin.py#L583
Package: mkdocs-manpage
MkDocs ManpageMkDocs plugin to generate a manpage from the documentation site.RequirementsPandoc must beinstalledand available aspandoc.InstallationWithpip:pipinstallmkdocs-manpage[preprocess]Withpipx:python3.8-mpipinstall--userpipx
pipxinstallmkdocs-manpage[preprocess]Usage# mkdocs.ymlplugins:-manpage:pages:-index.md-usage.md-reference/api.mdTo enable/disable the plugin with an environment variable:# mkdocs.ymlplugins:-manpage:enabled:!ENV[MANPAGE,false]Then set the environment variable and run MkDocs:MANPAGE=truemkdocsbuildThe manpage will be written into the root of the site directory
and namedmanpage.1.Pre-processing HTMLThis plugin works by concatenating the HTML from all selected pages
into a single file that is then converted to a manual page using Pandoc.With a complete conversion, the final manual page will not look so good.
For example images and SVG will be rendered as long strings of data and/or URIs.
So this plugin allows users to pre-process the HTML, to remove unwanted
HTML elements before converting the whole thing to a manpage.First, you must make sure to install thepreprocessextra:pipinstallmkdocs-manpage[preprocess]To pre-process the HTML, we useBeautifulSoup.
Users have to write their ownpreprocessfunction in order to modify the soup
returned by BeautifulSoup:frombs4importBeautifulSoup,Tagdefto_remove(tag:Tag)->bool:# remove images and SVGsiftag.namein{"img","svg"}:returnTrue# remove links containing images or SVGsiftag.name=="a"andtag.imgandto_remove(tag.img):returnTrue# remove permalinksiftag.name=="a"and"headerlink"intag.get("class",()):returnTruereturnFalsedefpreprocess(soup:BeautifulSoup)->None:forelementinsoup.find_all(to_remove):element.decompose()Then, instruct the plugin to use this module and itspreprocessfunction:plugins:-manpage:preprocess:scripts/preprocess.pySee the documentation of both [BeautifulSoup][bs4.BeautifulSoup] and [Tag][bs4.Tag]
to know what methods are available to correctly select the elements to remove.The alternative to HTML processing for improving the final manpage
is disabling some options from other plugins/extensions:no source code throughmkdocstrings:-mkdocstrings:handlers:python:options:show_source:!ENV[SHOW_SOURCE,true]no permalink throughtoc:markdown_extensions:-toc:permalink:!ENV[PERMALINK,true]Then set these environment variables before building
the documentation and generating the manpage:exportMANPAGE=trueexportPERMALINK=falseexportSHOW_SOURCE=falsemkdocsbuild
Package: mkdocs-manuals-theme
Theme for creating team manualsThis theme is based on top of mkdocs-basic-theme.https://github.com/mkdocs/mkdocs-basic-themeUsageInstall the themepipinstallmkdocs-manuals-themeUse the theme inmkdocs.ymltheme:name:manuals-themeDevelopmentSetting up dev environment:# create and activate virtual envpython3-mvenv.venvsource.venv/bin/activate# install requirementspipinstall'.[dev]'Summary of understandingThe documentation around templating is pretty good. It is all on one page :)https://www.mkdocs.org/dev-guide/themes/#navigation-objectsThere are 2 global variables on each page:navandtocNav is an iterable of 3 kinds of page:section,pageandlink