Saravanan666/pypi-org huggingface dataset:
Package: mezzanine-pageimages
mezzanine-pageimages====================Define (background-/banner-)images per page# The ProblemAt least our designer likes to create websites where pages can have individual backgrounds. Or individual banners. So for example the index-page has a generic background, while all pages under _Contact_ should have another background.Mezzanine has this great feature that templates are searched by`page-name.html`, `<content_type>.html` and then `page.html`. so onewould just create specific templates for the pages that get differentbackground. Its a nice solution that even works. But it has drawbacks:- To change the background, the designer has to ask the programmer because itcan't be changed in the admin-backend.- When you have multiple child-pages which should all get the background ofthe parent-page, you end up with templates for each page.- When the designer or writer adds another page, the programmer has to addanother template.Mostly the problem is mixing content with design-code.# The SolutionHere is how mezzanine-pageimages solves this:- In the admin-backend we just add a way to define images for certain rolesand specific to certain pages. Plus a way to define default-images for theroles.- We define a template-tag `pageimage` that takes a role and the looks forthe fitting image for the current page.- When there is no image for that role for the current page, it looks for animage on the parent page. It goes upwards until there is no parent or animage is found.- When there is still no image found, the default image for that role isreturned, if there is one defined.# InstallThis package is on pypi.python.org. To simply install it just do `pip install mezzanine-pageimage`. Or define it as a requirement in your _requirements.txt_ or _setup.py_.For hacking on mezzanine-pageimages do a git-checkout and install via `pip install -e`. Or install by `pip install -e git+https://github.com/bcs-de/mezzanine-pageimages.git#egg=mezzanine-pageimages`.# UsageAdd the app to your `INSTALLED_APPS`. You can define your own image-roles in the `SETTINGS` in settings.py:```pythonPAGEIMAGE_TYPES = (('BACKGROUND', 'Description text'),)```Then use it in your templates:```{% load pageimage_tags %}Lets get the url for the background image: {% pageimage 'BACKGROUND' %}```
Package: mezzanine-people
Overview========This pluggable app provides a "Person" model to categorize and list people on your Mezzanine sites.Requirements============[Mezzanine CMS] [1]Setup=====* Add mezzanine_people to your environment:```bashpip install mezzanine_people```* Add "mezzanine_people" to INSTALLED_APPS:```pythonINSTALLED_APPS = ("...","mezzanine_people",)```* Set values in your project settings.py (optional):```pythonPEOPLE_PER_PAGE = 5 # the default is 10```* Include the people URLconf in your project urls.py like this:```pythonurl(r'^people/', include('mezzanine_people.urls')),```* Run `python manage.py createdb` or `python manage.py syncdb && python manage.py migrate`.Releases--------+ Version 0.1 - Initial Release[1]: http://mezzanine.jupo.org "Mezzanine CMS"
Package: mezzanine-polls
Mezzanine Polls is a simple Poll application built for theDjangobased CMSMezzanine.FeaturesRestrict an user to vote several timesSeamlessly integrate with the Mezzanine CMSVote to see resultsInstallation and UsageInstall the app by usingpip:$ pip install mezzanine_pollsAddmezzanine_pollstoINSTALLED_APPSand synchronize/migrate the database.Go to the admin site and create new polls in thePagessectionDevelopmentNew features and fixes are welcome. Better if it comes with a patch or pull request. You can find the latest development sources atBitbucketorGitHub. Issues are only tracked at the Bitbucket project page.
Package: mezzanine-portfolio
# Mezzanine portfolio applicationMinimalistic Bootstrap theme for Django/Mezzanine.## Installation`pip install mezzanine-portfolio`## UsageIt is recommended to place the app at the end of INSTALLED_APPS list.INSTALLED_APPS = (...'portfolio',)##External Links* Django: www.djangoproject.com* Mezzanine: www.mezzanine.jupo.org* PyPI: www.pypi.python.org/pypi/mezzanine-theme-ascetic* Author: www.izhukov.herokuapp.com
Package: mezzanine-pubsubhubbub-pub
mezzanine_pubsubhubbub_pub==========================[![Build Status](https://travis-ci.org/kemsakurai/mezzanine-pubsubhubbub-pub.svg?branch=master)](https://travis-ci.org/kemsakurai/mezzanine-pubsubhubbub-pub)Publisher support of pubsubhubbub for mezzanine's blogInspired by [brutasse/django-push: PubSubHubbub support for Django](https://github.com/brutasse/django-push), this package is created.Requirements------------* mezzanine* requests* mock (for test)Installation------------```consolepip install mezzanine_pubsubhubbub_pub```Usage======================### add aplication to settings.py```pythonINSTALLED_APPS = ("mezzanine_pubsubhubbub_pub","mezzanine.boot","mezzanine.conf","mezzanine.generic",......```### add feed urlpatterns to urls.py```pythonfrom mezzanine_pubsubhubbub_pub import get_feed_url_patternsurlpatterns += get_feed_url_patterns()```### add PUSH_HUB to settings.pyPUSH_HUB is hub server to be notifiedThere can be multiple URL set in the Taple.Default : ```("https://pubsubhubbub.appspot.com/",)```This setting will not be editable via the admin.### add PUSH_URL_PROTOCOL to settings.pySet the protocol of the Feed URL to be notified .HTTP_ONLY, a HTTPS_ONLY, BOTH can be set ,BOTH is done the notification in the HTTP / HTTPS both the Feed URL.Default : ```HTTP_ONLY```This setting will be editable via the admin.TODO====* Support for the lower version* Flexible feed URL setting* Create batch jobs
Package: mezzanine-recipes
This plugin gives you a “Recipe” blog post type for your Mezzanine sites.FeaturesEmbed an image of the mealProvide an ingredient listLet your visitors add a comment and rating to recipesThe usual stuff - ingredients, times, categoriesREST-API for external applicationsInstallationRunpip installmezzanine-recipes(or, if you want to hack on mezzanine-recipes, clone it and runpip install-epath/to/repo)Create a Mezzanine CMS projectAdd"mezzanine_recipes"followed by"tastypie"on top of yourINSTALLED_APPSMigrate your database withpython manage.py migrate mezzanine_recipesInstall fixtures withpython manage.py loaddata mezzanine_required.jsonTo enable Recipe-Blog and REST API put following code to your urls.py:from mezzanine.conf import settings
from tastypie.api import Api
from mezzanine_recipes.api import *

v1_api = Api(api_name='v1')
v1_api.register(CategoryResource())
v1_api.register(KeywordResource())
v1_api.register(AssignedKeywordResource())
v1_api.register(PostResource())
v1_api.register(RecipeResource())
v1_api.register(BlogPostResource())
v1_api.register(IngredientResource())
v1_api.register(WorkingHoursResource())
v1_api.register(CookingTimeResource())
v1_api.register(RestPeriodResource())
v1_api.register(CommentResource())
v1_api.register(RatingResource())

urlpatterns = patterns("",
    ("^api/", include(v1_api.urls)),
    ("^%s/" % settings.BLOG_SLUG, include("mezzanine_recipes.urls")),
    ...Look athttp://www.robertstevens.org/mezzanine-recipes.htmlif you need a much more detailed installation instructionUsagemezzanine-recipe provides the blog post type “Recipe”. The Recipe blog post type represents a single recipe.Create a Recipe blog post in the Mezzanine admin (naming it something like “Recipe”).Creating TemplatesThe template for the Recipe List can be found attemplates/recipe/recipe_list.htmland for a Recipe Blog Post attemplates/recipe/recipe_detail.html.The Recipe object is available atmezzanine_recipes.models.recipe. It has the following properties:Periods and times:WorkingHours,CookingTime,RestPeriodCooking info:ingredients,portions,difficulty,categoriesText data:title,summary,content,comments,ratingsTo DoImplement some testsAdd single cooking steps to Recipe
Package: mezzanine-references
Customer references page and slideshow on homepage.Quick startInstall the appAddmezzanine_referencesin yourINSTALLED_APPSRunpython manage.py syncdbto create new database tablesOptionally includemezzanine-references.cssin yourbase.htmltemplate
or customize slideshow on your own.{%blockextra_css%}# Load stylesheet (optional)<linkrel="stylesheet"href="{% static "css/mezzanine-references.css" %}">{%endblock%}UsageFirst create page of type “References” in Mezzanine admin interface.References as slideshow{%loadreferences_tags%}# Create slideshow of reference page with title "Reference"{%references_slideshowtitle="Reference"%}
Package: mezzanine-sermons
mezzanine-sermons is for use with theMezzanine
CMS. It allows the management and display of sermons and sermon series.Requirementsmezzanine-sermons requires that the following python apps be
installed:Python 3.4Mezzanine 3.1 (and its dependencies)Django 1.7 +  (this app uses the django migrations framework)InstallationThe easiest method is to install directly from pypi usingpipby running the command below:$ pip install mezzanine-sermonsAdd mezzanine_sermons to INSTALLED_APPS in settings.py
immediately after your Django apps and before your Mezzanine apps:INSTALLED_APPS=(..."mezzanine_sermons",...)Runpython manage.py migrate mezzanine_sermonsto create the
mezzanine-slideshows models.The app comes with three templates which can hook into your project.
Hook the url into your projecturl(r'^sermons/',include('mezzanine_sermons.urls',namespace="sermons",app_name='mezzanine_sermons')),Then create pages using base.html at:
*   sermons
*   sermons/allseriesThe block {% full_width_content %} must appear in your base as this is where the template places the data.
Package: mezzanine-sirtrevor
mezzanine-sirtrevor=========[Sir Trevor editor] for [Mezzanine CMS]. It replaces the default editor with [Sir Trevor editor] . The code is taken from [django-sirtrevor] and made the appropriate changes to work with mezzanine and incorporate media library with image upload.Quick start-----------1. Install mezzanine-sirtrevor::> pip install mezzanine-sirtrevor2. Add ``sirtrevor`` to your INSTALLED_APPS setting like this::> INSTALLED_APPS = (>>   'sirtrevor'.>    .....> )3. Add sirtrevor urls::> url(r'^sirtrevor/', include('sirtrevor.urls')),4. add below settings> RICHTEXT_WIDGET_CLASS = "sirtrevor.widgets.SirTrevorWidget"> RICHTEXT_FILTERS = ("sirtrevor.filters.json_html",)-------**that's it. now you can see new editor in admin and inline editing area.**Limitation------------"sirtrevor" should be the first app in your installed apps list because it overrides editable.js. If you have your custom theme app then  you need to merge your app with sirtrevor app.Configuration-------------``SIRTREVOR_UPLOAD_PATH``Path where to store uploaded images relative to MEDIA_ROOT. (not configurable via widget kwargs) Defaults to uploadsPlease check [Sir Trevor editor] and [django-sirtrevor] for more configuration options.[Mezzanine CMS]:http://mezzanine.jupo.org/[Sir Trevor editor]:http://madebymany.github.io/sir-trevor-js/[django-sirtrevor]:https://github.com/philippbosch/django-sirtrevor[configuration options]:http://madebymany.github.io/sir-trevor-js/docs.html#2
Package: mezzanine-slides
mezzanine-slidesAdd simple slide functionality to your Mezzanine based website allowing for
beautiful banners at the tops of pages.SetupRunpip installmezzanine-slidesInsettings.pyaddmezzanine_slidesto yourINSTALLED_APPSabove
mezzanine apps.Run createdb or syncdb, if running syncdb run migrate if you are using South.Modify yourbase.htmltemplate as described below.TemplatesWe have two template options, fullscreen slides or standard slides. Include
only one of the templates, css and js.Standard SlidesAdd this tobase.htmlwhere you would like the slides to appear:{% include "includes/standard_slides.html" %}Include the CSS and JS in the compress areas of thebase.htmltemplate:{% compress css %}
...
<link rel="stylesheet" href="{% static "responsiveslides/responsiveslides.css" %}"/>
{% endcompress %}

{% compress js %}
...
<script src="{% static "responsiveslides/responsiveslides.min.js" %}"></script>
{% endcompress %}Fullscreen SlidesAdd this tobase.htmlwhere you would like the slides to appear:{% include "includes/fullscreen_slides.html" %}Include the CSS and JS in the compress areas of thebase.htmltemplate:{% compress css %}
...
<link rel="stylesheet" href="{% static "vegas/jquery.vegas.min.css" %}"/>
{% endcompress %}

{% compress js %}
...
<script src="{% static "vegas/jquery.vegas.min.js" %}"></script>
{% endcompress %}CreditsThanks toViljami SalminenforResponsiveSlides.jsplugin andJay SalvatforVegas Background jQuery Plugin.PWhipp: Enhanced to support Python 3
Package: mezzanine-slideshows
mezzanine-slideshows is for use with theMezzanine
CMS. It allows the placement of
Mezzanine Galleries within other Mezzanine Pages as slideshows.Requirementsmezzanine-slideshows requires that the following python apps be
installed:Python 3.4Mezzanine 3.1 (and its dependencies)Django 1.7 +  (this app uses the django migrations framework)InstallationThe easiest method is to install directly from pypi usingpipby running the command below:$ pip install mezzanine-slideshowsSuper Quick StartThese instructions are for instant setup with the Mezzanine demonstration installation and
allow you to place Mezzanine Galleriesat the endof other Mezzanine Pages as slideshows.
If you are using anything other than the standard templates provided with a fresh Mezzanine
install or wish to place the galleries at any place other than the end of pages please
follow the Regular Setup instructions below.Create a new Mezzanine project following theofficial
instructions.Add mezzanine_slideshows to INSTALLED_APPS in settings.py
immediately after your Django apps and before your Mezzanine apps:INSTALLED_APPS=(..."mezzanine_slideshows",...)Add the following to TEMPLATE_CONTEXT_PROCESSORS in settings.py:TEMPLATE_CONTEXT_PROCESSORS=(..."mezzanine_slideshows.context_processors.get_slideshows")Runpython manage.py migrate mezzanine_slideshowsto create the
mezzanine-slideshows models.Start the development server and visithttp://127.0.0.1:8000/admin/to create a slideshow instance.Navigate to the page on the site to see your gallery displayed after
the page text as a slideshow.Regular SetupAdd mezzanine_slideshows as an app in your project like this:INSTALLED_APPS=(..."mezzanine_slideshows")Add the following template context processor in settings.py:TEMPLATE_CONTEXT_PROCESSORS=(..."mezzanine_slideshows.context_processors.get_slideshows")Runpython manage.py migrate mezzanine_slideshowsto create the
mezzanine-slideshows models.In the header of your base.html file after the other css files add the lines<linkrel="stylesheet"href="{% static "mezzanine/css/magnific-popup.css"%}"><linkrel="stylesheet"href="{% static "mezzanine-slideshows/css/owl.carousel.css"%}"><linkrel="stylesheet"href="{% static "mezzanine-slideshows/css/owl.theme.css"%}">At the end of yourbase.htmlfile, just after{% include "includes/footer_scripts.html" %}add the following three lines:<scriptsrc="{% static "mezzanine-slideshows/js/owl.carousel.js"%}"></script><scriptsrc="{% static "mezzanine-slideshows/js/jquery.magnific-popup.js"%}"></script>This step is key. Without it no slideshows will appear. Add the following code to any place
you wish a template to check whether a slideshow should be displayed. If a slideshow is dues
to show on that page it will be displayed at that place in the template:{% include "includes/mezzanine_slideshows.html" %}
Package: mezzanine-sue
Theme for Mezzanine 4.0.1Add “sue” to your INSTALLED_APPS setting like this:INSTALLED_APPS = (
    "sue",
    ....# above other installed appsRun “python manage.py makemigrations”Run “python manage.py migrate”Change your URLsStart dev server and log into the admin interface, select a skin in the settings, and save.# uses Django migrations, make sure South is uninstalled
Package: mezzanine-sync-pages
mezzanine-sync-pagesmezzanine-sync-pages let you synchronize the contents of pages
in Mezzanine.
This comes in handy if you want to manage your page contents
as plain text/HTML files rather than in a web editor and if you
want to manage your content in a version control system like Git.It does synchronizeonlythe page contents and not any metadata
(like title, slug, publish date, ...).To create an initial dump of all existing pages in Mezzanine you can
use the management commanddump_pages.
To write back the previously dumped (and maybe modified) contents, use
thesync_pagesmanagement command or the corresponding action in the
admin interface.Features:Dump contents of all pages in Mezzanine as filesWrite back page contents to MezzanineDetect unmodified content and skip those pagesDisplay a diff on modified content after updatingInstallationThe easiest method is to install directly from pypi using pip:pip install mezzanine-sync-pagesIf you prefer, you can download mezzanine-sync-pages fromhttps://github.com/eht16/mezzanine-sync-pagesand install it directly from source:python setup.py installGet the SourceThe source code is available athttps://github.com/eht16/mezzanine-sync-pages/.ConfigurationAddmezzanine_sync_pagestoINSTALLED_APPSSetMEZZANINE_SYNC_PAGES_DESTINATION_PATHin your settings.py to the path
where the content files can be foundUsageAfter activating the app, two new management commands are added:dump_pages: create an initial dump of all pages in Mezzanine and
write the corresponding files inMEZZANINE_SYNC_PAGES_DESTINATION_PATHsync_pages: read all files fromMEZZANINE_SYNC_PAGES_DESTINATION_PATHand write their
content to MezzanineAdditionally, a new action in the Mezzanine admin interface is added to trigger the
synchronization of the pages to Mezzanine.ChangeLog1.0.1 / 2019-06-23Add trailing new line only if content is not empty
(fixes crashing on empty pages when dumping)1.0.0 / 2019-06-01Initial releaseLicensemezzanine-sync-pages is licensed under the MIT license.AuthorEnrico Trögerenrico.troeger@uvena.de
Package: mezzanine-theme-ascetic
# Mezzanine Theme AsceticMinimalistic Bootstrap theme for Django/Mezzanine.## Installation`pip install mezzanine-theme-ascetic`## UsageIt is recommended to place the themes as high as possible, to make sure all the app templates are overridden.INSTALLED_APPS = ('ascetic,...)##External Links* Django: www.djangoproject.com* Mezzanine: www.mezzanine.jupo.org* Mezzanine www.izhukov.herokuapp.com
Package: mezzanine-theme-moderna
Maintained and packaged version of awesomemoderna theme.SupportingMezzanine 4.2.0Django 1.10.1Python 3.5.2It may run with other versionsInstallAfter installing mezzaninepip installmezzanine-theme-modernaAdd"moderna"on yoursettings.pyINSTALLED_APPS=(..."django.contrib.staticfiles","moderna",...)
Package: mezzaninetheme-moderna
# Mezzanine Theme ModernaMaintained and packaged version of awesome [moderna theme](https://github.com/thecodinghouse/mezzanine-themes/tree/master/moderna).![moderna_ss](./img/ss.jpg)## Supporting* Mezzanine 4.2.0* Django 1.10.1* Python 3.5.2It may run with other versions## InstallAfter installing mezzanine* `pip install mezzaninetheme-moderna`* Add `"moderna"` on your `settings.py````pythonINSTALLED_APPS = (..."django.contrib.staticfiles","moderna",...)```
Package: mezzanine-tiles
Tiles is mezzanine content module which provide tile and section content which
which allow manage boxes/snipets etc. in our mezzanine cms. For example main
header slider which has some slides read content of every slide from tiles of
selected branch or section. Mezzanine organize pages in tree structure. Sections
exted to use it as graph (for example, we can select content from different branches).Detailed documentation is in the “docs” directory.Quick startAdd “tiles” to your INSTALLED_APPS setting in mezzanine project
like this:INSTALLED_APPS = (
    ...
    'tiles',
)Runpython manage.py migrateto create the tiless models.Start the development server and visithttp://127.0.0.1:8000/admin/to create new tile.Visithttp://127.0.0.1:8000/to check your work.
Package: mezzanine-vendors
A Django / Mezzanine application to manage a vendor catalog. Features:CSV importsUses the Google Maps API to determine coordinates from human-readable addressesCategorize vendors by service type and subjectInstallAdd your Google Maps API Key in yoursettings.pyasGOOGLE_MAPS_API_KEYInstall via pip:pip installmezzanine-vendors.Adddjango_google_mapsandimport_exporttoINSTALLED_APPS.Also addvendorsafter them.Includevendors.urlsin your root urlconf.Run migrations.Create Vendors, Subjects, and Types using the admin interface.Create your own viewsNote: This package provides the models, admin, and a JSON endpoint that returns the vendors. You’ll need to create your own frontend to display them.Management CommandRunpython manage.py add_vendor_locationsto add coordinates to vendors that are missing them (for example, vendors added via admin import). This uses Google’s GeoCoder API and will fail if the address cannot be parsed. It will also count towards the usage limit of your Google Maps API key.ContributingReview contribution guidelines atCONTRIBUTING.md.
Package: mezzanine-virtysue
Theme for Mezzanine 3.1.10Add “sue” to your INSTALLED_APPS setting like this:INSTALLED_APPS = (
    "sue",
    ....# above other installed appsRun “python manage.py schemamigration sue –initial” # Mezzanine 4+ “python manage.py makemigrations sue”Run “python manage.py migrate sue” # Mezzanine 4+ “python manage.py migrate sue”Change your URLsStart dev server and log into the admin interface, select a skin in the settings, and save.
Package: mezzanine-wiki
========Overview========Wiki application for Mezzanine.Features:- markdown syntax with [[Wiki links]] extension- page history and diff viewingRequirements:- Mezzanine >= 4.2.3- markdown- diff-match-patch=========Mezzanine=========Mezzanine is a content management platform built using the Djangoframework. It is BSD licensed and designed to provide both aconsistent interface for managing content, and a simple, extensiblearchitecture that makes diving in and hacking on the code as easy aspossible.Visit the Mezzanine project page to see some of the great sitespeople have built using Mezzanine.http://mezzanine.jupo.orghttp://github.com/stephenmcd/mezzanine===========This Fork===========This fork borrows heavily from the original project https://github.com/dfalk/mezzanine-wiki.Essentially the only changes are: updating the views to Class based, removing Southas the db and tweaking the urls.===========Quick start===========1. Activate your virtualenv (if applicable). Install mezzanine-wiki with "pip install mezzanine-wiki":2. Add "mezzanine_wiki" to your INSTALLED_APPS setting like this::INSTALLED_APPS = (...'mezzanine_wiki',)3. Add "mezzanine_wiki.WikiPage" to SEARCH_MODEL_CHOICES in your app's settings like this:SEARCH_MODEL_CHOICES = ('pages.Page', 'blog.BlogPost', 'mezzanine_wiki.WikiPage')4. Include the wiki URLconf in your project urls.py like this::url(r'^wiki/', include('mezzanine_wiki.urls')),5. To use the RTF editor add the following to your app's settings:WIKI_TEXT_WIDGET_CLASS = 'mezzanine.core.forms.TinyMceWidget'6. Run `python manage.py migrate` to create the wiki models.7. Restart server.8. Visit /wiki/ to use the wiki.