Saravanan666/pypi-org huggingface dataset:
Package: mdx-truly-sane-lists
Mdx Truly Sane ListsAn extension forPython-Markdownthat makes lists truly sane. Features custom indents for nested lists and fix for messy linebreaks and paragraphs between lists.Featuresnested_indentoption: Custom indent for nested lists. Defaults to2. Doesn't mess with code indents, which is still 4.truly_saneoption: Makes linebreaks and paragraphs in lists behave as usually expected by user. No longer adds weirdp, no extra linebreaks, no longer fuses lists together when they shouldn't be fused (see screenshots and examples below). Defaults toTrue.Inheritssane listsbehavior, which doesn't allow the mixing of ordered and unordered lists.InstallationPypi:pip3 install mdx_truly_sane_listsDirectly from git:pip3 install git+git://github.com/radude/mdx_truly_sane_listsUsageBasic:frommarkdownimportmarkdown# Default config is truly_sane: True, nested_indent: 2markdown(text='some text',extensions=['mdx_truly_sane_lists'])With explicit config:frommarkdownimportmarkdownmarkdown(text='some text',extensions=['mdx_truly_sane_lists',],extension_configs={'mdx_truly_sane_lists':{'nested_indent':2,'truly_sane':True,}},)Screenshots and examplesYou can preview the new behaviour live atrentry.co(usesnested_indent: 2, truly_sane: True)Some ugly screenshots because I'm lazy and cannot into gimp:HTMLData:-attributes-customer-first_name-family_name-email-person-first_name-family_name-birth_date-subscription_id-requestNo extension:<ul><li><p>attributes</p></li><li><p>customer</p><ul><li>first_name</li><li>family_name</li><li>email</li></ul></li><li>person<ul><li>first_name</li><li>family_name</li><li>birth_date</li></ul></li><li><p>subscription_id</p></li><li><p>request</p></li></ul>Truly sane + 4 spaces:<ul><li>attributes</li></ul><ul><li>customer<ul><li>first_name</li><li>family_name</li><li>email</li></ul></li><li>person<ul><li>first_name</li><li>family_name</li><li>birth_date</li></ul></li><li>subscription_id</li></ul><ul><li>request</li></ul>
Package: mdx-twitter
Markdown extension for embedding tweets using twitter OEmbed APIFree software: BSD licenseHow to useAllows you to embed tweets into your Markdown.Just install the package:pipinstallmdx-twitterBecause Twitter API 1.1 requires you to authenticate, you will need to create
a config file with your credentials at ‘~/.mdx_twitter.cfg’:[Twitter]
CONSUMER_KEY=xxxxxxxxxxxx
CONSUMER_SECRET=xxxxxxxxxxxx
ACCESS_TOKEN=xxxxxxxxxxxx
ACCESS_TOKEN_SECRET=xxxxxxxxxxxxThen just add ‘twitter’ to the list of your extensions:importmarkdownmd=markdown.Markdown(extensions=['twitter'])Twitter urls in your Makdown will become embedded tweets:https://twitter.com/jasoncosta/status/240192632003911681Django integrationSince Twitter has a rate limit on their APIs, and doing network calls all the
time just to render Markdown is a bad idea anyways, we would need some caching.If you are usingmdx-twitterin a Django project, it will automatically
use your cache settings to cache HTML returned from Twitter API.Also, you could place your API credentials in TWITTER_SETTINGS variable in your
project’ssettings.py, instead of using .cfg fileTWITTER_SETTINGS={'CONSUMER_KEY':'','CONSUMER_SECRET':'','ACCESS_TOKEN':'','ACCESS_TOKEN_SECRET':'',}Embedding tweets in UIWebViewThere are currently some problems with embedding tweets in UIWebView.Protocol agnostic src attribute “//platform.twitter.com/widgets.js” doesn’t
allow script to loadThere seems to be a problem with automatically determining width of the
containerhttps://dev.twitter.com/discussions/15450So there is a ‘width’ configuration option that offers a quick ‘fix’ for those
problems. Just specify expected width of your tweet in pixels.importmarkdownmd=markdown.Markdown(extensions=['twitter(width=300)'])It will only work with ‘style’ full.StylesYou can customize appearance of your tweets using ‘style’ configuration
options. Default style is ‘full’, which includes script javascript, you could
also use ‘simple’ style, which just includes tweet in a blockquote tag without
javascript.Another option would be to specify a path to your own function, which accepts
Twitter response json as an argument and should return final html.An example custom style is included in the library. You can use it by
specifying ‘style=mdx_twitter.custom_style’TODOIf we embed multiple tweets, we don’t need to havescripttag after each
tweet. We should probably just have ascripttag at the end of the
document.History0.1.0 (2013-08-31)First release on PyPI.
Package: mdx-unimoji
Unicode Emojis for Python-MarkdownConverts defined emoticon symbols to Unicode emojis, supported on a
variety of devices1.Usage:>>>from__future__importprint_function>>>frommarkdownimportmarkdown>>>text='I <3 you! :P'>>>print(markdown(text,['mdx_unimoji']))# doctest: +NORMALIZE_WHITESPACE<p>I<spanclass="emoji"style="color:red">❤</span>you!<spanclass="emoji">😛</span></p>NOTE: The emojis are only replaced when whitespace-delimited on both sides!The following options are accepted:emoji, the emoticon-to-list-of-aliases mapping,span_class, the class name of the encompassing<span>element
(default: 'emoji'). No element is created ifNone.An example with these custom settings:>>>frommdx_unimojiimportUnimojiExtension>>>img_heart='<img alt="love" src="heart.png"/>'>>>img_tongue='<img alt=":P" src="tongue.png"/>'>>>overrides=UnimojiExtension.EMOJI>>>overrides.update({img_heart:['<3'],...img_tongue:':p :P :-p :-P'.split()})>>>print(markdown(text,...extensions=[UnimojiExtension(span_class='other',...emoji=overrides)]))...# doctest: +NORMALIZE_WHITESPACE<p>I<imgalt="love"class="other"src="heart.png"/>you!\<imgalt=":P"class="other"src="tongue.png"/></p>You can use thespan_classvalue in your CSS, e.g.:.emoji {
    font-family: "Apple Color Emoji", "Segoe UI Emoji",
                 "Noto Color Emoji", EmojiSymbols, "DejaVu Sans", Symbola;
}InstallTo install and make available to Markdown, you can issue:pip install mdx_unimojiorpip install --upgrade git+git://github.com/kernc/mdx_unimoji.gitThen use the above provided examples to figure your way around.HF!
Package: mdx-variables
mdx_variablesA Markdown extension to add support for variables.Licensed under theISC License.RequirementsThe mdx_variables plugin requires only the basemarkdownlibrary.InstallationInstall withpip install mdx_variables.DocumentationAllows inserting variables into Markdown.The following Markdown example:This paragraph contains ${chickens} chickens.This paragraph contains no chickens but ${foxes} foxes.Are there ninjas here? ${ninjas}.Might result in:This paragraph contains 5 chickens.This paragraph contains no chickens but 3 foxes.Are there ninjas here? ninjas not found.Python usage:md=markdown.Markdown(extensions=['variables',],extension_configs={'variables':{'vars':{'chickens':'5','foxes':(lambda:3),'__getattr__':(lambdaname:"{}not found".format(name)),},}})Configuration options:vars: A dictionary mapping variable names to variable values.If a value is a function, that function will be called without arguments and
the result will be used as the variable value.The special variable__getattr__may specify a functionf(name)->valueto call when no matching variable is found.
Package: me2-packager
AboutThis work is part of the mOSAIC project open-source outcomes released under the Apache 2.0 license (see the “Notice” section below).http://developers.mosaic-cloud.eu/…me2-packager is the packaging component of the mOSAIC execution engine. It is mainly responsible for packaging filesystem images as ‘mosaic bundles’, bundles
that can be executed in the context of the mosaic-supervisor.ContentsAboutQuickStartNoticeQuickStartInstall using pip:$ pip install me2-packagerme2-packager is driven by spec.json files. This files provide the “recipe” for building an ‘mosaic bundle’.
An example is athttp://goo.gl/knEgrNoticeThis product includes software developed at “Institute e-Austria, Timisoara”,
as part of the “mOSAIC – Open-Source API and Platform for Multiple Clouds”
research project (an EC FP7-ICT Grant, agreement 256910).http://developers.mosaic-cloud.eu/http://www.ieat.ro/This is an internal component in themOSAICCloud Project. The current state of the component is experimental.Copyright:Copyright 2010-2013, Institute e-Austria, Timisoara, Romania
    http://www.ieat.ro/

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at:
    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: me7-ba11
THE MEATBALL for line ctf libMeatball is a small library that manages files.
You can check the fast-managed data here.
It supports simple AES encryption.
There are small vulnerabilities that may occur when managing files.fromme7_ba11.meatballimportMeatBall## Create meatball and create data# append datamb=MeatBall('meat.ball',)data={data:'meatball'}key=mb.append(data)data=mb.get(key)print(data){'uuid key':'meatball'}# update datadata={'key':'uuid key','data':'meatball_change'}mb.update(data)data=mb.get(key)print(data){'uuid key':'meatball_change'}## File upload and update# uploadwithopen('file','rb) as f:_file=f.read()data={data:'meatball'}<-Parametersarenotusedwhenuploadingfiles.key=mb.append(data,_file)data=mb.get(key)print(data){'uuid key':'encoded file binary'}# update to filedata={'key':'uuid key','data':'meatball'}<-Parametersarenotusedwhenuploadingfiles.mb.update(data,_file)data=mb.get(key)print(data){'uuid key':'encoded file binary'}## Encryption# append data with encryptionmb=MeatBall('meat.ball',)data={data:'meatball',enc='on'}key=mb.append(data)data=mb.get(key)print(data){'uuid key':'meatball'}# update data with encrtyptiondata={'key':'uuid key',enc='on','data':'meatball_change'}mb.update(data)data=mb.get(key)print(data){'uuid key':'meatball_change'}
Package: mead-audio8
audio8API examples using8-milefor audioImplementationThe codebase relies primarily on8-mile(mead-layers) for its modeling and optimization code.
Whats left is pretty much just training and inference codeDependenciesThe code depends on:editdistance(for error evaluation)numpysixsoundfilemead-baselinepytorchThere are a few optional dependenciesscipy(for on-the-fly resampling of wav files)ctcdecode(for prefix beam decoding with optional LM)
Package: mead-baseline
MEADMEAD is a library for reproducible deep learning research and fast model
development for NLP. It provides easily extensible abstractions and
implementations for data loading, model development, training, experiment tracking and export to production.It also provides implementations of high-performance deep learning models for various NLP tasks, against which newly developed models
can be compared. Deep learning experiments are hard to reproduce, MEAD
provides functionalities to track them. The goal is to allow a researcher to
focus on model development, delegating the repetitive tasks to the library.DocumentationTutorials using ColabMEAD HubInstallationPipBaseline can be installed as a Python package.pip install mead-baselineYou will need to havetensorflow_addonsalready installed or have it get installed directly with:pip install mead-baseline[tf2]From the repositoryIf you have a clone of this repostory and want to install from it:cd layers
pip install -e .
cd ../
pip install -e .This first installsmead-layersAKA 8 mile, a tiny layers API containing PyTorch and TensorFlow primitives, locally and thenmead-baselineDockerhubWe use Github CI/CD to automatically release TensorFlow and PyTorch via this project:https://github.com/mead-ml/mead-gpuLinks to the latest dockerhub images can be found thereA Note About VersionsDeep Learning Frameworks are evolving quickly and changes are not always
backwards compatible. We recommend recent versions of whichever framework is being used underneath.  We currently test on TF versions 2.1.0 and 2.4.1.
The PyTorch backend requires at least version 1.3.0, though we recommend using a more recent version.CitingIf you use the library, please cite the following paper:@InProceedings{W18-2506,
  author =    "Pressel, Daniel
               and Ray Choudhury, Sagnik
               and Lester, Brian
               and Zhao, Yanjie
               and Barta, Matt",
  title =     "Baseline: A Library for Rapid Modeling, Experimentation and
               Development of Deep Learning Algorithms targeting NLP",
  booktitle = "Proceedings of Workshop for NLP Open Source Software (NLP-OSS)",
  year =      "2018",
  publisher = "Association for Computational Linguistics",
  pages =     "34--40",
  location =  "Melbourne, Australia",
  url =       "http://aclweb.org/anthology/W18-2506"
}MEAD was selected for a Spotlight Poster at the NeurIPS MLOSS workshop in 2018.OpenReview linkAcknowledgementsResearch supported with Cloud TPUs from Google's TPU Research Cloud (TRC)
Package: meadowrun
Meadowrun is a library for data scientists and data engineers who run python code on
AWS, Azure, or Kubernetes. Meadowrun:scales from a single function to thousands of distributed tasks.syncs your local code and libraries for a faster, easier iteration loop. Edit your
code and rerun your analysis without worrying about building packages or Docker
images.optimizes for cost, choosing the cheapest instance types and turning them off when
they're no longer needed.For more context, see ourcase
studiesof how Meadowrun is used in
real life, or see theproject homepageTo get started, go to ourdocumentation, orjoin the chat
on GitterQuickstartFirst, install Meadowrun using pip:pip install meadowrunNext, assuming you'veconfigured the AWS
CLIand are a root/administrator user, you can run:importmeadowrunimportasyncioprint(asyncio.run(meadowrun.run_function(lambda:sum(range(1000))/1000,meadowrun.AllocEC2Instance(),meadowrun.Resources(logical_cpu=1,memory_gb=8,max_eviction_rate=80),meadowrun.Deployment.mirror_local())))The documentationhas examples of how to use other package
managers (conda, poetry), and other platforms (Azure, GKE, Kubernetes).
Package: mead-xpctl
XPCTLxpctlis software to track experimental results and provide access to a global leaderboard. After running an experiment, the results and the logs are committed to a database. Commands are provided to show the best experimental results under various constraints.xpctlwas developed as the primary backend for experiment storage formead-baseline.Prerequisitexpctlrequires a database to be installed locally or an accessible server. We currently support:mongodbandpostgresql), but the base classes can be extended to support other databases. Create a database calledreporting_dbin your db instance.The client API is packaged separately with minimal requirements.InstallationThere are 2 components:mead-xpctl-clientandmead-xpctlmead-xpctl-clientprovides the HTTP client and the addon required to run logging from insidemead-baselinemead-xpctlcontains the CLI and the server implementationBoth packages can be installed via pip:pip install mead-xpctl-clientpip install mead-xpctl(this depends on themead-xpctl-client)Install the serverDocumentation
Package: meager
MeagerMeager is a tiny web framework built on the socketserver module in Python.InstallationMeager is available onPyPI.You can install meager using pip:pip install meagerExamplesThis is the simplest way of using meager, returning html upon a request to "/".The module is heavily inspired by flask, and it's ease of use, and readability.Example returning htmlimportmeagerapp=meager.Server(host="0.0.0.0",port=8080)# Set binding ip address and port, default is localhost:2090@app.router.route("/")defindex(request):return"<h1>Hello world!</h1>"app.serve()Example returning JSONimportmeagerapp=meager.Server()example_dict={"key1":"val1","key2":"val2"}@app.router.route("/")defindex(request):returnexample_dict# It can detect if you're sending a dictionary# and automatically changes the "Content-Type:" header to application/jsonapp.serve()Dynamic GET exampleimportmeagerapp=meager.Server()@app.router.route(request,"/api/<name>")defapi(name):return{"status":"success","name":name}app.serve()
Package: mealdb
MealDBTheMealDB API client forPython.DownloadPyPIpip install mealdbExamplefrommealdbimportsearchformealinsearch("Shawarma"):print(meal.strMeal)DocumentationpdocLicenseMealDB is released under theApache License 2.0.Copyright 2022 XXIV

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
Package: mealieapi
Mealie APIIf you are running a self-hostedMealieserver you can use this library to authenticate yourself with and intereact with it!
Create mealplans, import recipes, remove users, modify user groups, upload recipe images.
All with MealieAPI.Installation$pipinstallmealieapiUsageAuthenticationTo start you need your Mealie server url, and your login credentials or an API key (which you can create athttps://[YOUR_MEALIE_SERVER]/admin/profile).
MealieAPI uses theasync/awaitsyntax so you must run it inside an async function or event loop like so (if you are not familiar with async applications already.)importasynciofrommealieapiimportMealieClientclient=MealieClient("<YOUR_MEALIE_SERVER_ADDRESS>")This next part depends on whether you have an API key, or your login credentials.If you want to use your username and password you must useawait client.login("<USERNAME_OR_EMAIL>", "<PASSWORD>")or if you are using an API key you need to useclient.authorize("<API_KEY>")(Note: without the await).asyncdefmain():awaitclient.login("<USERNAME_OR_EMAIL>","<PASSWORD>")# ORclient.authorize("<API_KEY>")loop=asyncio.get_event_loop()loop.run_until_complete(main())DocsA work in progress.ContributionsAll contributions are welcome! Thats what makes Open-Source so special.
Package: meal-plan-skill
Meal PlanSuggests a meal for you to makeAboutSuggests a meal for you to make, based on a short default list, but you can manage your own meals!Examples"What should I make for dinner?""What should I eat?""What should I eat tonight?""I'm hungry""What's for dinner?"CreditsMike Graymike@graywind.orgCategoryDailyProductivityTagsFood meal planning
Food
Meal
Planning
Meal planning
Package: mealsearchpy
mealsearchpyA Python package for people to search what they still have left in the fridge and provide relevent recipes the food gets wasted by using Recipe Search API. The package comprises the functionality of allowing users to enter the left ingridients left in the fridge, such as "chicken", "potato" as input and return relevent recipes, which inlcudes 5 functions:search_meal(food_item, num_recipes): Show the recipes based on the food item(s) entered and the number of recipes user wants to generate.health_meal(food_item, health_type, calories, num_recipes): Show the recipes based on the food item(s), health type(s), calories entered and the number of recipes user wants to generate.diet_meal(food_item, diet_type, calories, num_recipes): Show the recipes based on the food item(s), diet type(s), calories entered and the number of recipes user wants to generate.quick_meal(food_item, time, num_recipes): Show the recipes based on the food item(s), and cook time entered and the number of recipes user wants to generate.cuisine_meal(food_item, cuisine_type, num_recipes): Show the recipes based on the food item(s), cuisine type(s) entered and the number of recipes user wants to generate.API: Recipe Search APIHome Page:https://api.edamam.comAPI Portal:https://api.edamam.com/api/recipes/v2Authenticaiton: This API need users to REGISTER to get the API ID and API key for authentication in order to explore the recipes data.Installation$pipinstallmealsearchpyThe package has been published to pypi.pypi:https://pypi.org/project/mealsearchpy/UsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensemealsearchpywas created by Anni Dai. It is licensed under the terms of the MIT license.Creditsmealsearchpywas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: meanas
meanasmeanasis a python package for electromagnetic simulations** UNSTABLE / WORK IN PROGRESS **Formerly known asfdfd_tools.This package is intended for building simulation inputs, analyzing
simulation outputs, and running short simulations on unspecialized hardware.
It is designed to provide tooling and a baseline for other, high-performance
purpose- and hardware-specific solvers.ContentsFinite difference frequency domain (FDFD)Library of sparse matrices for representing the electromagnetic wave
equation in 3D, as well as auxiliary matrices for conversion between fieldsWaveguide mode operatorsWaveguide mode eigensolverStretched-coordinate PML boundaries (SCPML)Functional versions of most operatorsAnisotropic media (limited to diagonal elements eps_xx, eps_yy, eps_zz, mu_xx, ...)Arbitrary distributions of perfect electric and magnetic conductors (PEC / PMC)Finite difference time domain (FDTD)Basic Maxwell time-stepsPoynting vector and energy calculationConvolutional PMLsThis package doesnotprovide a fast matrix solver, though by defaultmeanas.fdfd.solvers.generic(...)will callscipy.sparse.linalg.qmr(...)to perform a solve.
For 2D FDFD problems this should be fine; likewise, the waveguide mode
solver uses scipy's eigenvalue solver, with reasonable results.For solving large (or 3D) FDFD problems, I recommend a GPU-based iterative
solver, such asopencl_fdfdor
those included inMAGMA. Your
solver will need the ability to solve complex symmetric (non-Hermitian)
linear systems, ideally with double precision.Source repositoryPyPITBDInstallationRequirements:python >=3.8numpyscipyInstall from PyPI with pip:pip3install'meanas[dev]'Development installInstall python3 and git:# This is for Debian/Ubuntu/other-apt-based systems; you may need an alternative commandsudoaptinstallpython3build-essentialpython3-devgitIn-place development install:# Download using gitgitclonehttps://mpxd.net/code/jan/meanas.git# If you'd like to create a virtualenv, do so:python3-mvenvmy_venv# If you are using a virtualenv, activate itsourcemy_venv/bin/activate# Install in-place (-e, editable) from ./meanas, including development dependencies ([dev])pip3install--user-e'./meanas[dev]'# Run testscdmeanas
python3-mpytest-rsxX|teetest_results.txtSee also:git bookvenv documentationpython language referencepython standard libraryUseSeeexamples/for some simple examples; you may need additional
packages such asgridlockto run the examples.