Saravanan666/pypi-org huggingface dataset:
Package: marisco
mariscoThe IAEAMarine Radioactivity Information System
(MARIS)allows free access to users to
search and download the results of measurements of radioactivity in
seawater, biota, sediment and suspended matter. MARIS is maintained and
developed by theIAEA Environmental
Laboratoriesin Monaco.The present Python package provides command-line utilities to:Encode harvested datasets asNetCDFor.csvformatsInteract with theIAEA Open Data platform soon availableProvide data preprocessing pipelines for ad-hoc datasets…PrerequisitesWe recommend to use the“Mamba” python package
managerto create a clean and
“deterministic” python environment.Once installed, a typical Mamba workflow could be:#Createanisolatedenv.withyourpreferedpythonversionmamba create -n name-of-your-env python=3.9#Thenmamba activate name-of-your-envmamba install your-packages-of-interestmamba deactivate # To quit your environmentInstall & configurationNow, to installmariscosimply runpip install mariscoOnce successfully installed, run the following command:maris_initThis script will create a.marisco/directory containing various
configuration/configurable files in your/homedirectory including:cdl.toml: MARISNetCDF4 CDL (Common Data
Language.configs.toml: contains several configurable constants, default
paths, …lut/: directory containing several MARIS DB nomenclature filesmaris-template.nc: MARIS NetCDF4 template generated from thecdland use to encode MARIS datasetsNotes:conda/mambainstaller will be also available soon.How to useCommand line utilitiesAll commands accept a-hargument to get access to its documentation.maris_initCreate configuration files, MARIS NetCDF CDL (Common Data Language) and
donwload required lookup tables (nomenclatures).maris_create_nc_templateGenerate MARIS NetCDF template to be used when encoding datasetsmaris_netcdfyEncode MARIS dataset as NetCDF using Jupyter Notebook handlersPositional arguments:data: Path to dataset to encodenb_in: Path to Jupyter noteboook (NetCDF handler) to executenc_out: Path to generated NetCDF4Example:maris_netcdfy _data/xls/tepco/coastal_water.xlsx nbs/handlers/tepco.ipynb _data/output/tepco.nc
Package: maritime-schema
maritime-schemaPython package containing data classes and corresponding JSON schemata for common types used in generating traffic scenarios and testing of autonomous navigation systems.The data classes in the package are implemented as data models using thepydanticframework.All data classes reside in subpackagemaritime_schema.typesand can be imported from there.Installationpipinstallmaritime-schemaUsage ExampleAPI:frommaritime_schema.typesimport...CLI:The JSON schemata are contained in the repository in folder ./schema
If you did not clone the repository but installed the maritime-schema package as a dependency in your project you can callpublish-schemaon the command line to (re-)generate the schemata:publish-schemaThepublish-schemacommand will generate the JSON schemata in(current working directory)/schemaand a corresponding html documentation of the schemata in(current working directory)/docs/schemaFor more examples and usage, please refer to maritime-schema'sdocumentation.Development SetupInstall Python 3.9 or higher, i.e.Python 3.10orPython 3.11Update pip and setuptools:python-mpipinstall--upgradepipsetuptoolsgit clone the maritime-schema repository into your local development directory:gitclonehttps://github.com/dnv-opensource/maritime-schemapath/to/your/dev/maritime-schemaIn the maritime-schema root folder:Create a Python virtual environment:python-mvenv.venvActivate the virtual environment:..on Windows:>.venv\Scripts\activate.bat..on Linux:source.venv/bin/activateUpdate pip and setuptools:(.venv)$python-mpipinstall--upgradepipsetuptoolsInstall maritime-schema's dependencies:(.venv)$pipinstall-rrequirements-dev.txtThis should return without errors.Finally, install maritime-schema itself, yet not as a regular package but as aneditablepackage instead, using the pip install option -e:(.venv)$pipinstall-e.Test that the installation works (in the maritime-schema root folder):(.venv)$pytest.MetaCopyright (c) 2024DNVAS. All rights reserved.Minos Hemrich -minos.hemrich@dnv.comTom Arne Pedersen -tom.arne.pedersen@dnv.comClaas Rostock -@LinkedIn-claas.rostock@dnv.comDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/dnv-opensource/maritime-schemaContributingFork it (https://github.com/dnv-opensource/maritime-schema/fork)Create your branch (git checkout -b my-branch-name)Commit your changes (git commit -am 'place a descriptive commit message here')Push to the branch (git push origin my-branch-name)Create a new Pull Request in GitHubFor your contribution, please make sure you follow theSTYLEGUIDEbefore creating the Pull Request.
Package: marius
## Marius--------Light weight job scheduling tool with more performance and scalability.<br/>Name come from [Gaius Marius](https://en.wikipedia.org/wiki/Gaius_Marius)### Installation```shellpip install marius```### Usage Example```pythonimport timefrom marius import Task, TimeLinedef func(num):print('task-{0}'.format(num))if __name__ == '__main__':tl = TimeLine()now = time.time()tl.add(Task(iter([now + i for i in [2, 3, 5]]), func, 3))while tl.has_tasks():tl.wait_next()tl.run()else:print("all job run over")```### TODO1. ~~add automatic test support~~2. ~~add more helper function~~3. add doc### Welcome to contributeFeel free to open a issue or start a pull request. <br/>You are welcome.
Package: marjoram-org
Polls is a simple Django app to conduct Web-based polls. For each
question, visitors can choose between a fixed number of answers.Detailed documentation is in the “docs” directory.Quick startAdd “polls” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'orgapp',
]Include the polls URLconf in your project urls.py like this:url(r'^org/', include('orgapp.urls')),Runpython manage.py migrateto create the orgs models.Start the development server and visithttp://127.0.0.1:8000/admin/to create an organization (you’ll need the Admin app enabled).
Package: mark1-translate
Mark1 TranslatorThis is a small tool to translate from Google Translate, base on mtranslate bymouuffIt was reduce to the minimum expression and converted to use requestsInstallNote: this instructions are made for ubuntuIt is highly recommended to use it inside a virtual enviroment for your project, but can be install globally with$pip3installmark1_translateOr in a virtual enviroment$virtualenv.venv
$source.venv/bin/activate
$pipinstallmark1_translate
$python3ExampleOn interactive console type>>>frommark1_translateimprttranslate>>>translate('hola mundo','en','auto')'Hello World'On a projectfrommark1_translateimprttranslatet=translate('hola mundo','en','auto')print(t)
Package: mark2
mark2 is a minecraft server wrapper, written in python and twisted. It aims to
bethedefinitive wrapper, providing a rich feature-set and a powerful plugin
interface. It has no requirement on craftbukkit.featuresYour server runs in the backgroundMultiple users can attach at once, with their own local prompt and command
bufferBuilt in monitoring using cpu, memory, players and connectivityRich screen/tmux-like client with built-in monitoring, tab-complete, command
history, etcpluginsPowerful scheduling plugin, with a cron-like syntax. You can hook onto events
like@serverstoppedto run a
cartograph, or runsaveon an intervalAutomatically restart the server when it crashes, runs out of memory, or
stops accepting connectionsNotifications via Prowl, Pushover, NotifyMyAndroid or email if something goes
wrong.Relay in-game chat to IRC, and vice-versaMCBouncer ban support, even on a vanilla server.Read an RSS feed (such as a subreddit feed) and announce new entries in-gameBack up your map and server log when the server stopsPrint a random message at an interval, e.g. ‘[SERVER] Lock your chests with
/lock’Respond to user commands, e.g. ‘<Notch> !teamspeak’ couldmsg Notch Join our
teamspeak server at xyz.com
Package: mark3
mark3 provides a lightweight,markdownto html parser for python 2.7 and 3.UsageUsing mark3 is very simple:from mark3.markdown import markdown
html = markdown(raw_text)Deviationsmark3 may differ slightly from the official markdown implementation.If you find a difference between mark3’s output and the official markdown’s not
mentioned here, pleaseopen a ticket.ListsA <p> will be placed in an <li> if, andonly ifit’s needed:* foo
* barWill produce the same output as:* foo

* barInline HTMLThis markdown:< foo <b>bar</b>>Produces:<p>&lt; foo <b>bar</b>&gt;</p>Instead of the official markdown implementation output:<p>&lt; foo <b>bar</b>></p>TabsTabs are expanded to 4 spaces before parsing. As such, output will never
contain tabs.Insignificant WhitespaceOutputted html doesn’t have as much insignificant whitespace as the official
markdown implementation.
Package: markable
MARKABLEAim:Render text in terminalHEXcolor tag string. e.g.'#ff00ff'RGBtuple. e.g.(255, 0, 255)Render single/multiple linesGlobal triggerHow to use:Note: Marker.print() method inherited few parameters from print(end='\n',flush=False,file=sys.stdout)- Proceed a single line:frommarkableimportMarkerMarker.print(line='Hello World!',fg='#ff0000')# case-insensitiveMarker.print(line='Hello World!',fg=(255,0,0))- Proceed a multiple lines:frommarkableimportMarkerMarker.set_color(bg='#ffff00')# set start pointprint('SOMETHING')# doprint('TEST')# somethinprint('DEBUG')# hereMarker.reset_color()# reset to default- Global trigger:frommarkableimportMarkerMarker.SWITCH=FalseIf you like my work, please consider buying me a coffee orPayPalThanks for your support! Cheers! 🎉
Package: markalgo
Lightweight library which implementsMarkov
algorithm(cycle of
replacements) for text strings.Usage:creating rulesfrom markalgo import rules
from markalgo import processing

# from text
replacement = rules.create_rules([("Norwegian blue", "parrot"), ("alive", "dead"), ("dead", "no more")])

# or from csv files
with open("notes/cicero.csv") as argumentation:
    replacement = rules.read_all_rules_from_csv_file(argumentation)processing text…processing.process_text("This Norwegian blue is alive", replacement)

 *"This parrot is no more"*…or plain-text fileswith open("notes/note.txt") as argumentation:
    processing.process_file()
Package: markapp
MarkappLiterate Markdown for Apps™This project helps generatesindex.html,style.css, andscript.jsfrom code blocks in Markdown files.Generative AI is all the rage, but it can be cumbersome to try out code that it generates.
This script allows us to manages notes and code snippets in a single file and
break them up into multiple files for easy web serving.Example Usagepipinstallmarkapp# Get list of optionsmarkapp--help#   Usage: markapp [OPTIONS] SRC##     Compile markdown files into HTML##   Options:#     --output-dir TEXT   Output directory#     --watch             Watch for changes and recompile#     --debounce INTEGER  Debounce time in milliseconds#     --serve             Serve the output directory#     --host TEXT         Serve host#     --port INTEGER      Serve port#     --help              Show this message and exit.#     Compile markdown files into HTMLmarkapptests/sample.md--output-dir.# Will generate `sample` directory with the following structure:treesample#  sample#  ├── index.html#  ├── script.js#  └── style.cssSample Markdown# Really Cool Prompt

Make me a website with html, css, and javascript in their own files.

```html
inner html
```

```css
inner css
```

```javascript
inner javascript
```Markdown OptionsHere is a slightly more complex example.# Really Cool Prompt

Make me a website with html, css, and javascript in their own files.

```html > index.html
inner html
```

```css > css/style.css
inner css
```

```javascript >> script/app.js
inner javascript
```How to tell your generative AI to create these code blocks?!Here is an example prompt to get you started:Your MUST respond with Literate Markdown. For example:Each fenced code block must begin with three backticks followed by a language, space, greater than, space, and a file path.You may append to a previous file by using two greater thans and then the file name.Example create block:console.log('hello')Example append block:</code></pre></li></ul></blockquote><pre><code>
Package: markata-gh
Markata ghInstallationpip install markata-ghUsagemarkta-ghis a jinja plugin for markata, once installed it can be enabled through the following config.[markata.jinja_md]extensions=['markata_gh.repo_list.GhRepoListTopic']Inside your markdown you can use thegh_repo_list_topictag.## Markata plugins{% gh_repo_list_topic "markata" %}ExampleLicensemarkata-ghis distributed under the terms of theMITlicense.
Package: markata-slides
Markata SlidesA slide plugin for markata.Heavily inspired by lookatme.  I have been a long time user of creating slides
in markdown, and lookatme has long been my go to slide viewer.  It works great
for many applications, but sometimes the terminal does not work for the
audience, and other times I want some good looking images in my presentation.markata-slidesbuilds a website with forward/backward buttons, and j/k
hotkeys similar to lookatme.Installationpipinstallmarkata-slidesUsageYou can runmarkata-slidesfrom the command line, ormarkata slidesand it
will automatically add itself to the plugin registry.markata-slidesIf you want to use the standard markata cli commands make sure that you addmarkata_slidesto your configuredhooks.# markata.toml[markata]hooks=['default','markata_slides']markatabuild
markatatui
Package: markbassmodel
# MarkBassModelTheMarkBassModelpackage is a Python package that provides functions for fitting and predicting using the Bass diffusion model.## DescriptionThe Bass diffusion model is a popular method in marketing analytics used to forecast the rate of adoption of new products in a market. The MarkBassModel package offers functionality to assist with various tasks related to product marketing and adoption, including:Forecasting product salesEstimating market potential through diffusion analysisComparing the performance of different products## FunctionsThe MarkBassModel package provides the following functions:###diffusion(sales)This function calculates the cumulative diffusion curve based on the sales data provided.###adoption_rate(t, p, q, m, N)This function calculates the adoption rate at a given time based on the Bass diffusion model’s parameters.t: Time at which the adoption rate is calculated.p: Coefficient of innovation.q: Coefficient of imitation.m: Total market potential.N: Cumulative number of adopters at timet.###bass_f(t, p, q)This function calculates the Bass diffusion curve at a given time based on the Bass diffusion model’s parameters.###bass_F(t, p, q)This function calculates the cumulative Bass diffusion curve at a given time based on the Bass diffusion model’s parameters.###predict_bass_model(params, m)This function predicts the diffusion of a new product using the Bass diffusion model’s parameters (pandq) and the total market potential (m).###plot_bass(p, q, title)This function plots the Bass diffusion curve for the given parameterspandq. Thetitleparameter specifies the title of the plot.## InstallationYou can install the MarkBassModel package using pip:`shell pip install markbassmodel `## UsageTo use the MarkBassModel package, start by importing it:`python import markbassmodel `To calculate the parameters:`python markbassmodel.diffusion(sales) `To plot the Bass diffusion curve:`pythonmarkbassmodel.plot_bass(params['p'],params['q'],'Bass diffusion curve') `## Example DataYou can find a sample dataset of smartphone sales over a period of time [here](https://drive.google.com/drive/folders/1rtiKrg9xa2TMH8cTqN2l-eHWqQG1ZH6c?usp=sharing). You can use this dataset to test and experiment with the MarkBassModel package.## LicenseThe MarkBassModel package is released under the [MIT License](https://opensource.org/licenses/MIT).
Package: markd2html
Markdown to HTML PackageDescription:A Python package, designed to convert the Github mark down syntax to HTML code.Supporting Featuresheadingstext styling: Bold, Italic, Strikethrough, Bold and italicunordered and ordered listsparagraphsMultiple and Single line Code BlocksSetext for <h1> and <h2> Tagshorizontal rule <hr> tagLink text (Hyperlinks)Image linksinline codeWeb links (example:https://www.google.com)accepts html tags <img> inside a <p> tag*Note: Additional support in progressInstallpython3 -m pip install markdown-to-htmlUsage>>> from markdown2html import md2html
>>> md2html.markdown("**Hello**")
'\n<p><strong>Hello</strong></p>\n'Command Line Interface$ md2html -h
usage: Input a file [-h] [-f F]

optional arguments:
-h, --help  show this help message and exit
-f F$ md2html -f Alpha.md > Output.html
Package: markdgenerator
markdgeneratorThis is a short library to help generate text inpandoc markdownlanguage with.So far, it supports:h1, h2, h3 headingsparagraphscode blockstables ingrid_tableformatalso generated from a pandas DataFrameIt's extendable to support more markdown languages.Output of the tool can be converted into multiple document formats usingpandocand its--from=markdownoptionInstallationpip install markdgeneratorExample usagefrommarkdgeneratorimportPandocMdGeneratorimportpandasaspdgenerator=PandocMdGenerator()generator.h1("Example")generator.paragraph("Pandas dataframe example")generator.add_block_to_section()df=pd.DataFrame(columns=["car","price"],data=[["vw",10000],["bmw",20000],["mercedes",30000]])generator.df_to_table(df)generator.add_table_to_section()print(generator)which leads to:# Cars

This document lists prices of german cars.

+--------+-----+
|car     |price|
+========+=====+
|vw      |10000|
+--------+-----+
|bmw     |20000|
+--------+-----+
|mercedes|30000|
+--------+-----+This can be passed to pandoc and converted to a different format.
Package: markdown2
markdown2: A fast and complete Python implementation of Markdown.Markdown is a text-to-HTML filter; it translates an easy-to-read /
easy-to-write structured text format into HTML.  Markdown’s text
format is most similar to that of plain text email, and supports
features such as headers,emphasis, code blocks, blockquotes, and
links.  –http://daringfireball.net/projects/markdown/This is a fast and complete Python implementation of the Markdown
spec. Seehttp://github.com/trentm/python-markdown2for more info.
Package: markdown2ctags
This application generates ctags-compatible output for the sections of a
Markdown document.The motivation was to have a tool fast enough to use with theTagBarplugin in Vim.Using with TagBarTo use this tool with TagBar, add the following into your~/.vimrc:" Add support for markdown files in tagbar.
let g:tagbar_type_markdown = {
    \ 'ctagstype': 'markdown',
    \ 'ctagsbin' : '/path/to/markdown2ctags.py',
    \ 'ctagsargs' : '-f - --sort=yes --sro=»',
    \ 'kinds' : [
        \ 's:sections',
        \ 'i:images'
    \ ],
    \ 'sro' : '»',
    \ 'kind2scope' : {
        \ 's' : 'section',
    \ },
    \ 'sort': 0,
\ }NoteThe suggestedsroused to be|, but this symbol could be used in
headings (when talking about logical operators, for example).  As a result,
I recommend using something like the UTF-8 chevron above and specifying this
new sro character on the command line via the--srooption.However, some folks have had issues with the chevron–TagBar is failing to
split on the character correctly and it results in incorrect headings that
contain<bb>in TagBar.  I’m not sure what the underlying cause is just
yet, but if you’re suffering from this issue, you may want to fall back to
using the|character.  You can do this by dropping the--sro=»parameter fromctagsargsand setting'sro'to'|'.You’ll need to have the TagBar plugin installed for this to work.  Also, you
may need to call the variableg:tagbar_type_mkdand changectagstypeto'mkd'if you’re Ben William’s Markdown syntax highlighting script.  It sets
the file type tomkdwhereas Tim Pope’s sets it tomarkdown.LicenseThis tool is licensed under a Simplified BSD license.  SeeLICENSE.txtfor
details.
Package: markdown2html
## Requirementssudo apt-get install pandoc## Installsudo pip install markdown2html## Usageusage: md2html [-h] [-v] [-k] [-s STYLE] files [files ...]positional arguments:files                 Files you want to convertoptional arguments:-h, --help            show this help message and exit-v, --verbose         Display infos-k, --keep            Keep an existing output file (overwrites by default)-s STYLE, --style STYLEGive a css file to be embedded in the html output## DetailsYou can find the default css file used in `md2html/style-templates/style.css`.
Package: markdown2latex
Extension to python-markdown to support LaTeX (rather than html) output.Authored by Rufus Pollock: <http://www.rufuspollock.org/>Usage:1. Command Line. A script entitled markdown2latex.py is automatically
installed. For details of usage see help:$ markdown2latex.py -hAs a python-markdown extension:>>> import markdown
>>> md = markdown.Markdown(None, extensions=['latex'])
>>> # text is input string ...
>>> latex_out = md.convert(text)Directly as a module (slight inversion of std markdown extension setup):>>> import markdown
>>> import mdx_latex
>>> md = markdown.Markdown()
>>> latex_mdx = mdx_latex.LaTeXExtension()
>>> latex_mdx.extendMarkdown(md, markdown.__dict__)
>>> out = md.convert(text)HistoryVersion: 1.0 (November 15, 2006)First working version (compatible with markdown 1.5)Includes support for tablesVersion: 1.1 (January 17, 2007)Support for verbatim and imagesVersion: 1.2 (June 2008)Refactor as an extension.Make into a proper python/setuptools package.Tested with markdown 1.7 but should work with 1.6 and (possibly) 1.5
(though pre/post processor stuff not as worked out there)Version 1.3: (July 2008)Improvements to image output (width)Version 1.3.1: (August 2009)Tiny bugfix to remove duplicate keyword argument and set zip_safe=FalseAdd [width=\textwidth] by default for included images