Saravanan666/pypi-org huggingface dataset:
Package: md-tangle
md-tangleThis project is a result of wanting config and setup files to be part of a document
explaining my setup. I originally usedOrg-modeandorg-babel-tangleinEmacsto achieve this. I really like Org-mode and Emacs, but I'm not fond of
being dependent on one editor. This is the reason I wanted aCLI, and a more
widely used documentmarkup language.This way of programming is calledliterate programming. This programming paradigm
was introduced by Donald Knuth. The idea is to write a program as an explanation of the
program logic in a natural language interspersed with snippets of traditional source code.
The source code can then be generated ("tangled") by using some tool.AsMarkdownis used by most programmers, I saw that language fit for the task.
Markdown is a plaintext-ish format popular with programmers. It's simple, easy and
already has support for embedding code blocks using ``` or ~~~~, mostly
for the purposes of syntax highlighting in documentation.InstallingThis CLI tool can easily be utilized by addingmd-tangleto yourPATH, or by installing the package withpip.See the package onpypi.org, or just install withpip install md-tangle.CommandBy adding the keywordtangle:<path/filename>, this tool will tangle tagged code
blocks to given file. Supports~for home directory.One can tangle the code block to multiple files by separating the files with chosen separator (default:,).If the file already exists, the user will be prompted with the option to overwrite,
unless the-f/--forceflag is added.Flags-h/--help: Show help message and exit--version: Show installed version-f/--force: Force overwrite of files if the already exists-v/--verbose: Show output-d/--destination: Overwrite output destination-s/--separator: Separator for tangle destinations (default=',')UsageTake the following example:HelloWorld.md# Some titleDescribing the following code... bla bla.

~~~~javascript tangle:helloWorld.js
console.log("Hello, ");
console.log("world");
~~~~## StylingAdding header for my css files:

~~~~css tangle:styles/button.css,styles/input.css
/* Styling for mye awesome app */
~~~~

By adding some css ... 

~~~~css tangle:styles/button.css#button1 {border: none;
}
~~~~

~~~~css tangle:styles/input.css#button1 {border: none;
}
~~~~By installingmd-tanglewithpip, one could simply produce files from this file by executing:$md-tangle-vHelloWorld.mdhelloWorld.js2lines
styles/button.css4lines
styles/input.css4lines
$lshelloWorld.jsHelloWorld.mdstylesDocumentationThedocumentationformd-tangleis of course written in Markdown, and tangles to the source
code.
Package: mdtc
ReadmeMDTC - Model-driven TOML Configuration.A lightweight config singleton meant for storing your application's config state no matter where or how many times it is instantiated.
You can pass this object around across your entire app and not worry about config mutations, unvalidated config values or lack of IDE completions.
Originally meant for use with TOML key/value-based configs, but any k/v object should work as long as it complies with the model.The source documentation can be foundhereWhat is MDTC for?Avoids having to use or chain.get()or retrieve config values viacfg["foo"]["bar"]["baz"].Code-completion-friendly via model-driven approach.Custom configuration validation (either via Pydantic's interfaces or custom-built validators you define).Immutable config state support. The config itself is immutable by default - you cannot replaceconfig.foowith another value, for instance.Supports nicer type hints instead of a huge TypeDict or another approach for a config dictionary loaded into Python.What MDTC is not forIt is not meant to replace other methods of loading TOML or dict configs, it simply provides an alternative for housing your TOML config values.It is not meant as "less code". The guarantees it provides require a different implementation approach, and won't always result in less upfront code.Codebases using other approaches or small configs won't benefit from this approach as much.DependenciesNone, just the Python standard library.ExamplesSimple Configurationimporttomllib# python3.11-only, use tomli for <=3.10fromdataclassesimportdataclassfrommdtcimportConfig@dataclassclassFooCfg:foo:strbar:str_name:str="misc"_key:str="config.misc"classMyConf(Config):misc:FooCfgcfg="""[config.misc]foo="bar"bar="baz""""toml=tomllib.loads(cfg)config=MyConf(toml)Pydantic Models in your Configurationimporttomllib# python3.11-only, use tomli for <=3.10frompydanticimportBaseModelfrommdtcimportConfigclassFooCfg(BaseModel):_name:str="misc"_key:str="config.misc"foo:strbar:strclassMyConf(Config):misc:FooCfgcfg="""[config.misc]foo="bar"bar="baz""""toml=tomllib.loads(cfg)config=MyConf(toml)PydanticdataclassExampleimporttomllib# python3.11-only, use tomli for <=3.10frompydanticimportField,validatorfrompydantic.dataclassesimportdataclassfrommdtcimportConfig@dataclassclassFooCfg:foo:strbar:str=Field(title="A bar to get drinks in..")_name:str="misc"_key:str="config.misc"@validator("foo")defname_must_contain_space(cls,v):if" "inv:raiseValueError("must NOT contain a space!")returnv.title()classMyConf(Config):misc:FooCfgcfg="""[config.misc]foo="bar"bar="baz""""toml=tomllib.loads(cfg)config=MyConf(toml)ContributingComing soon..
Package: md-template
Markdown TemplateA tool to help primarily with generating Markdown tables based on a set of files. This is particularly useful to repositories that contain several subprojects, such as userscript repos.InstallationThis will installmd-templateandnatsortas well asPyYAMLfor the userscript preset.pipinstallmd-template[full]For the most minimal installation.pipinstallmd-template# or with natsort (recommended)pipinstallmd-template[natsort]UsageCommand-lineThe easiest but most restricted method.# md-template --helpmd-templatetable--presetscoop--dry-runClass-basedSeetable.presetsfor more detailed examples.frompathlibimportPathfromtypingimportIterablefrommdtemplate.tableimportTableTemplateclassMyTemplate(TableTemplate):files="bucket/*.json"columns=("Name","Branch")source="README.md"# defaultdefhandle_path(self,path:Path)->Iterable[Iterable[str]]:# create a rowyield[# include information using the current filepathf"Column 1: **{path.name}**",# use information from the git repositoryf"Column 2:{self.repository.branch}",]if__name__=="__main__":MyTemplate().parse_args().render()Function-basedfrompathlibimportPathfromtypingimportIterablefrommdtemplate.tableimportTableTemplatedefhandle_path(self:TableTemplate,path:Path)->Iterable[Iterable[str]]:# create a rowyield[# include information using the current filepathf"Column 1: **{path.name}**",# use information from the git repositoryf"Column 2:{self.repository.branch}",]if__name__=="__main__":TableTemplate(files="bucket/*.json",columns=("Name","Branch"),source="README.md",# defaulthandle_path=handle_path,).parse_args().render()OutputBoth the class-based and function-based examples above generate the same table.Input# My Repository<!-- table -->
<!-- table-end -->Output# My Repository<!-- table -->
| Name | Branch |
| ---- | ------ |
| Column 1:**filename.json**| Column 2: main |
<!-- table-end -->
Package: mdtex2html
mdtex2htmlpython3-library to convert Markdown with included LaTeX-Formulas to HTML with MathMLWhat is mdtex2htmlmdtex2htmlis a library to convert (Github-flavored) Markdown-Code with included LaTex-formulas to HTML-Source. The formulas are converted to MathML.An inline-formula can either start and end with$or it can start with\(and end with\), according to valid LaTeX-Code. Block-formulas either start and end with$$or start with\[and end with\].An example thatmdtex2htmlwill convert:# Example-Title

TeX-Formula: $\sqrt2=x^2 \Rightarrow x=\sqrt{\sqrt{2}}$

- This
- is
    - a List with `inline-Code`How to use mdtex2htmlinstall it, i.e. using pip:python3 -m pip install mdtex2htmlthen in python import in your code withimport mdtex2htmland convert your mdTeX with something likemdtex2html.convert('- Hello ${\sqrt{World}}^2$!')passing any mdTeX-Code tomdtex2html.convert().ExtraYou may want to (but don't need to) include this css-snippet on your page to hide error message texts, only showing on mouse-over:.tooltip .tooltiptext {
    display: none;
}
.tooltip:hover .tooltiptext {
    display: inline;
    border-radius: 0.3em;
    background-color: #777;
    position: fixed;
}Markdown-ExtensionsStarting with v1.1 you can use python-markdown-extensions for i.e. tables, definition-lists, html-attributes and much more by passing a list of the extension(s) to be used to theconvert-command as described in thepython-markdown documentation.For examplemdtex2html.convert('Hello green\n{: style="color:green" }', extensions=['attr_list'])will make use of the extensionattr_list.DependenciesThis depends on:latex2htmlPython-MarkdownThe dependencies will be installed when installing using pip.LimitationsThe Firefox browser will display the result smoothly, as well as Safari (according to user reports).Just be aware that the Chromium-engine (Browsers: Chrome, Edge, ...) still is not able to render MathML properly, but rumors say that in 2020 work has started again to make that happen, so maybe you want to check the status there.In 2023 MathML Core got finally supported by the Blink-Engine of Chrome (and therefore Edge etc.). So this works now in all mainstream-browsers.CreditsSpecial thanks toRonie Martinezfor creatinglatex2html!This library is just a few lines of code added to his work and toPython-Markdown.
Package: mdtf-test-data
mdtf_test_datais a Python package in the public domain
that processes and generates coarse-resolutions datasets
that are suitable for testing process-oriented diagnostics
that are part of theModel Diagnostics Task Force Package.The package provides two types of functionality:Coarsening the horizontal resolution of existing dataGenerating synthetic NCAR or GFDL-formatted dataMore InformationSource code:http://github.com/jkrasting/mdtf_test_data
Package: mdtob64
mdtob64--markdown图片转base64程序导入包使用 from mdtob64.mdtob64 import mdtob64命令行运行 mdtob64需要填写两个参数文件路径需要包括文件本身，需要写上格式.md新文件默认存放当前目录下，只需要写上文件名路径或者文件名任意一个输入空则视为取消操作##v0.0.4增加了标识，备份的文件也可以直接追加内容
Package: md-toc-creator
MD TOCA tool to create tables of contents from markdown files, in markdown
format.Introductionmd-toc-creator is a tool written in python that adheres to the old
Unix philosophy of doing one thing and one thing well. It reads a given
markdown file (or standard input) and produces a table of contents. The
TOC can be generated  with or without links, in markdown format, based
on any headings that may exist in the document, as well as their level.Usage Information./mdtoc.py-husage: MD TOC [-h] [-m {1,2,3,4,5,6}] [-M {0,1,2,3,4,5,6}] [-n] [-o OUTPUT]
              [-s SEPARATOR] [-w WHITESPACE] [-x LEVEL]
              [input]

Generate a table of contents for a markdown document

positional arguments:
  input                 The markdown file to read.

optional arguments:
  -h, --help            show this help message and exit
  -m {1,2,3,4,5,6}, --min-indent {1,2,3,4,5,6}
                        Specify the minimum level of heading for which the
                        list items will be indented. Headings at or below this
                        level will not be indented and the rest of the heading
                        levels will be adjusted accordingly. The default is 1.
  -M {0,1,2,3,4,5,6}, --max-indent {0,1,2,3,4,5,6}
                        Specify the maximum level of heading for which the
                        list items will be indented. Headings above this level
                        will not be indented any further; Thus, specifying 0
                        flattens the list. The default is 6.
  -n, --no-links        Do not link the sections of the document to their list
                        items in the table of contents.
  -o OUTPUT, --output OUTPUT
                        The markdown file to write the table of contents to.
                        The default is standard output.
  -s SEPARATOR, --separator SEPARATOR
                        Specifies a string to be used as the separator between
                        the '*' character and the succeeding list item
                        (default: ' ').
  -w WHITESPACE, --whitespace WHITESPACE
                        Specify the characters used as whitespace before each
                        item. This is repeated or omitted depending on the
                        indentation level of each item. (default: ' ')
  -x LEVEL, --exclude LEVEL
                        Specify specific levels of heading to exclude from the
                        table of contents. This option can be repeated to
                        exclude multiple levels.

Submit any bugs to https://github.com/mcb2003/md-toc-creater/issues/new
Package: md-to-conf
Markdown to Confluence ConverterThis tool can be used to import markdown documents into Confluence.  It is a fork ofRittmanMead/md_to_conf, upgraded to Python 3.11 and the Confluence v2 APIs.The file is converted to HTML and uploaded to Confluence using theirstoragerepresentation.  The following functionality is supported:Inline imagesCode blocksSome custom markdown tagsUsagePlease see theGetting Starteddocumentation for information on using this tool.ContributingPlease see theContributesection of the documentation for information on development and contribution guidelines.Change LogChange Log
Package: md-to-html
Python module for converting markdown files to HTML. Forked from:https://github.com/AumitLeon/module_starter_cliMarkdown to HTML ConverterThe purpose of this project is to create a simple to use python module that can convert markdown files into rich HTML.Table of ContentsRequirementsInstallationUsageContributingThis project is preconfigured withCircleCifor continuous integration and delivery; releases are automated viasemantic-release.RequirementsThis module requires python version >= 3.5.InstallationTo install this module:pip install md-to-htmlUsageThis module's usage is summarized below:usage: md-to-html [-h] --input INPUT [--output OUTPUT]

Convert Markdown File to HTML file

optional arguments:
  -h, --help show this help message and exit
  --input INPUT, -i INPUT input markdown file
  --output OUTPUT, -o OUTPUT output HTML fileContributingIf you find this project useful and would like to contribute back to it, feel free to check out theCONTRIBUTINGpage.DisclaimerThis project uses themistune libraryfor parsing markdown into html. Disclaimer below:Copyright (c) 2014, Hsiaoming YangAll rights reserved.Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.Neither the name of the creator nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: mdtohtmlfromju
MDtoHTMLCe projet est sous license publique MIT.Comment ca marche ?C'est trÃ¨s simple, il suffit d'installer le programme et ses addons.Pour installer les addons, il faut ouvrir un terminal de commande et Ã©crire :Veillez Ã  modifier FOLDER_PATH par le chemin d'accÃ¨s du dossier ou vous avez installÃ© le MDtoHTML.cd FOLDER_PATH
pip install -r requirements.txtPour lancer le convertisseur il suffit de crÃ©er un (ou plusieurs fichiers) au format.MDdans un dossier quelconque et de lancer le programme dans un terminal.python converter.pyIl suffit d'y ajouter des arguments, accessibles via --help Ã  la suite de la commande ci dessus.Voici la liste des arguments ici :--dirOU--input_directory ( Permet Ã  l'utilisateur de convertir tous les fichiers MD d'un dossier avec une seule commande )--i ( Si l'utilisateur veut prÃ©ciser un fichier Ã  convertir en particulier )--oOU--output_directory ( La commande permettant de choisir la destination du fichier HTML sortant )--title ( Commande permettant de changer le titre de ses page HTML converties )Librairie communautaireVous pouvez retrouver le package en tapant cette commande afin de l'utiliser dans d'autres projets :pip install mdtohtmlfromjuLien vers le package :https://pypi.org/project/mdtohtmlfromju/Si vous vous retrouvez avec ceci, c'est que le package est bien installÃ© :pip install mdtohtmlfromju
Collecting mdtohtmlfromju
  Downloading https://files.pythonhosted.org/packages/2e/88/908b916ea18fddeb6855a328b8d9d8618203d7b379c0267ec5910db717d9/mdtohtmlfromju-1.0.0-py3-none-any.whl
Installing collected packages: mdtohtmlfromju
Successfully installed mdtohtmlfromju-1.0.0
Package: mdtoolbelt
mdtoolbeltTools por MD post-processingImportant: PIP only installs the package. All the dependencies must be installed separately. To perform a complete installation, please use ANACONDA.ConversionsConvert structure and trajectory files from one format to anotherPythonfrommdtoolbelt.conversionsimportconvertconvert(input_trajectory_filename='trajectory.xtc',output_trajectory_filename='trajectory.dcd')Bashmdtbconvert-ittrajectory.xtc-ottrajectory.dcd
Package: mdtoreveal
mdtorevealIt's an extremly basicMarkdowntoreveal.jsconversion tool.Yes reveal already supports Markdown, but it needs specifically
crafted Markdown with strange separators which I don't personally
like. And yes you can also do this using pandoc but it mess with
syntax highlighting by handling it.Usagemdtoreveal my_prez.md --output my_prez.htmlIt's also allowed to skip the output file, so its name is guessed, the
previous command is equivalent to the following one:mdtoreveal my_prez.mdSyntaxLet's start with pure Markdown:# Big titles makes reveal.js "columns"

## Sub titles make reveal.js "slides" inside columns.

```python
print("Syntax highlighting works")
```

::: notes

Look, this is a personal note, it's not mandatory to use them, but you still can.
Everything betwen `::: notes` and the next slide is only visible by the presenter.

## 2nd slide

Blah blah …ExampleIt convertsthisintothis(this one uses a.gitlab-ci.ymlto publish on push).ConfigurationThere's not, deal with it, don't loose your time on fine-tuning, and
focus on your presentation.Still, you prefer a dark theme? It's unreadable on video projectors,
keep this one, trust me.You want bigger code blocks? You already have 12 lines and 61 columns,
if you stuff more, it won't be readable anyway, stick to it.You want a bigger font for your code blocks, so it's still readable
from the end of the room? I can understand that, I used to use a
bigger one too, let's talk in the issues.You're using a Makefile?Me too ♥ this should do:SRCS:=$(wildcard*.md)HTML:=$(SRCS:.md=.html).PHONY:staticstatic:$(HTML)%.html:%.mdmdtoreveal$<-o$@
Package: mdToRst
mdToRstTool and library to convert markdown to restructed text (md to rst).This tool performs some basic conversions to attempt to generate a restructed text document (RST) which renders the same, or as close as possible to a provided markdown (md).This tool is not perfect, and may require that you write your markdown in a certain way that is apt toward conversion, but it does save a lot of time and prevent error.Why?It does not make sense and is very error prone to manage two different copies of the same documentation.I really like markdown, and I absolutely despise restructed text.Unfortunately, github prefers markdown and pypi will only use RST, so all of my python projects need to have a distinct MD and RST.The goal here is to simplify things to where you only have to write and maintain a markdown copy (README.md), and after changes you simply run README.md through mdToRst in order to output README.rst .UsageUsage: mdToRst [filename]Converts a provided markdown file (.md) to restructed text (.rst)If “filename” is provided as “--”, the markdown will be read from stdin.Example Usage:mdToRst README.md | tee README.rst  # Read in README.md, convert to rst,#  and output both to stdout and “README.rst”cat README.md | mdToRst         # Pipe in the contents of “README.md”, and#  output the converted document to stdoutModificationIf you have a usage scenario where mdToRst generates incorrect or suboptimal results, please submit an issue detailing:How to reproduce the issueWhat the expected result isWhy this makes senseHow to achieve the equivilant in RSTand optionally submit a patch as well.
Package: mdtraj
MDTraj is a python library that allows users to manipulate molecular dynamics
(MD) trajectories and perform a variety of analyses, including fast RMSD,
solvent accessible surface area, hydrogen bonding, etc. A highlight of MDTraj
is the wide variety of molecular dynamics trajectory file formats which are
supported, including RCSB pdb, GROMACS xtc, tng, and trr, CHARMM / NAMD dcd, AMBER
binpos, AMBER NetCDF, AMBER mdcrd, TINKER arc and MDTraj HDF5.
Package: mdtraj-duplicate
MDTraj is a python library that allows users to manipulate molecular dynamics
(MD) trajectories and perform a variety of analyses, including fast RMSD,
solvent accessible surface area, hydrogen bonding, etc. A highlight of MDTraj
is the wide variety of molecular dynamics trajectory file formats which are
supported, including RCSB pdb, GROMACS xtc, tng, and trr, CHARMM / NAMD dcd, AMBER
binpos, AMBER NetCDF, AMBER mdcrd, TINKER arc and MDTraj HDF5.