Saravanan666/pypi-org huggingface dataset:
Package: mezzanine-announcements
Mezzanine AnnouncementsA Mezzanine app to create and display site-wide announcements.FeaturesSchedulable announcements (start and end datetimes)Define as many announcement types as you want in settingsMake announcements optionally dismissable by the userAn announcement will not bother the user after they have dismissed itOptionally make the announcement reappear after a set amount of daysAdd an optional time delay after page load before showing an announcementInstallationInstall via pip:pip install mezzanine-announcementsAdd to"announcements"toINSTALLED_APPS.Run migrations.Add"announcements.context_processors.announcements"to your context processors.Define the list of announcement templates that will be available for your admin users. This is a tuple of two-value tuples defined insettings.ANNOUNCEMENTS_TEMPLATESwhere the first element is the path to the Django template to be used, and the second element is the friendly name displayed in the admin for said template. For example:ANNOUNCEMENTS_TEMPLATES=(("announcements/modal.html","Modal"),("announcements/top_bar.html","Top bar"),)You need to create this templates yourself. An example is provided below.Add some announcements in the new "Announcements" section in the admin.Then to display the announcements in your templates:Add the cookies and announcement scripts to the templates where you want to use the announcements<script src="{%static'js/js.cookie.js'%}"></script><script src="{%static'js/announcements.js'%}"></script>Include the template with all announcements in a{% nevercache %}block:{%nevercache%}{%include"announcements/announcements.html"%}{%endnevercache%}TemplatesYou can use any markup and styling you want in the announcement templates
defined insettings.ANNOUNCEMENTS_TEMPLATES. You could use a Bootstrap modal,
or simple horizontal bar on the top of your page. The only conditions that you
need to keep in mind are the following:The template must contain a single element of the classannouncement.The announcement ID, delay, and expiration must be present as data attributes
on the.announcementelement.If the announcement is dismissable, you must include a clickable element with
the classclose-announcementas a child of.announcement.{%loadmezzanine_tags%}<divclass="announcement"data-appearance-delay="{{announcement.appearance_delay}}"data-announcement-id="{{announcement.id}}"data-expire-days="{{announcement.expire_days}}">{{announcement.content|richtext_filters|safe}}{%ifannouncement.can_dismiss%}<button class="close-announcement">Close</button>{%endif%}</div>SettingsNameDefault valueDescriptionANNOUNCEMENTS_TEMPLATESNoneList of templates available for announcements. See Templates section aboveANNOUNCEMENTS_EXTRA_FIELDSNoneList of additional fields to display in the announcement admin: ["extra_content", "video_link", "form"]ContributingReview contribution guidelines atCONTRIBUTING.md.
Package: mezzanine-api
Mezzanine API is aRESTful web APIfor the popularMezzaninecontent management platform.
It is built upon theDjangoframework, usingJSONfor serialization andOAuth2for secure authentication.
The API empowers developers toautomate, extend and combine Mezzanine with other servicessuch as mobile apps.Why use the API?Freedom: build mobile, web, or server apps and use whatever programming language you wantSpeed: harness a significant speed advantage over Mezzanine’s Python based page viewsFeaturesIntuitive REST API resources for posts, categories, comments, pages, users, and site/app metadata. Retrieving or updating data involves simply sending a HTTP request.Easily filter and search contentIndustry standard OAuth2 API authentication allows users to authorize and revoke access to third party applicationsWeb browsable APIInteractive API resource documentationInstallation, Documentation and RoadmapPlease visithttp://gcushen.github.io/mezzanine-apiScreenshotCreated byGeorge Cushen
Package: mezzanine-articles
Articles is mezzanine content module which provide article content which
integrate together richtextopage, gallery, add link to other pages utility
and sections extension (for improve styling, grouping, etc.). 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 “articles” to your INSTALLED_APPS setting in mezzanine project
like this:INSTALLED_APPS = (
    ...
    'articles',
)Runpython manage.py migrateto create the articles models.Start the development server and visithttp://127.0.0.1:8000/admin/to create new article.Visithttp://127.0.0.1:8000/to check your work.
Package: mezzanine-bookmarks
WARNING: mezzanine-bookmarks is under development.mezzanine-bookmarks is a bookmark service built on Django and Mezzanine designed to be flexible and easy to use.
You could host it as a standalone bookmark service for multiple users. Or you could embed it into an existing mezzanine site.Here is the feature list:Multiple User supportSingle User modeUse service from www.diffbot.com to extract main content from web pageUse service from api.zemanta.com to generate suggested tagsStore page content for future useINSTALLEMBED INSTALLmezzanine-bookmarks could be used as a django app:pip install mezzanine-bookmarksThen add'bookmarks',to INSTALLED_APPS and add("^bookmarks/",include("bookmarks.urls")),tourls.py.STANDALONE INSTALLmezzanine-bookmarks comes with a standalone mode which you could use run a bookmark service with it very quickly:virtualenv bookmarks
source bookmarks/bin/activate
pip install mezzanine-bookmarks
pip install django-template-bootstrap
bookmarks init
vim ~/.bookmarks/bookmarks.conf.py # Add your own diffbot and zemanta api keys
bookmarks syncdb
bookmarks migrate
bookmarks runserver
Package: mezzanine-bsbanners
Making it easier to manage attention grabbing Bootstrap Carousels and
compelling Bootstrap Jumbotrons as banners on home pagesDesigned to quickly and easily manange attention grabbing Bootstrap carousels
and compelling Bootstrap Jumbotrons as banners with the same ease as ordinary
Mezzanine pages without editing templates.The following Bootstrap layouts are supported:CarouselJumbotronImage (using card)Quick startInstall the appAdd “mezzanine_bsbanners” to your INSTALLED_APPS setting like this:INSTALLED_APPS = (
    ...
    'mezzanine_bsbanners',
)Add blocks menu item to admin menu (Optional):ADMIN_MENU_ORDER = (
    ("Content", (
            "mezzanine_bsbanners.*",
        )
    ),
)Run ‘python manage.py migrate’ to create the database models.Usagemezzanine-bsbanners are similar to django-flatblocks.Include bsbanners_tags in the template:{% load ... bsbanners_tags %}Insert block anywhere in the template:{% bsbanner "My Banner" %}
{% bsbanner {block} %}
{% bsbanner {block} "my_template.html" %}
{% bsbanner {block} {template_name} %}DependenciesDjango2.0Mezzanine4.xBootstrap4.xSupportTo report a security issue, please send an email privately toahicks@p-o.co.uk. This gives us a chance to fix the issue and
create an official release prior to the issue being made
public.For general questions or comments, please contactahicks@p-o.co.uk.Project websiteCommunications are expected to conform to theDjango Code of Conduct.
Package: mezzanine-buffer
=============================mezzanine-buffer=============================.. image:: https://badge.fury.io/py/mezzanine-buffer.png:target: https://badge.fury.io/py/mezzanine-buffer.. image:: https://travis-ci.org/caffodian/mezzanine-buffer.png?branch=master:target: https://travis-ci.org/caffodian/mezzanine-buffer.. image:: https://coveralls.io/repos/caffodian/mezzanine-buffer/badge.png?branch=master:target: https://coveralls.io/r/caffodian/mezzanine-buffer?branch=masterBuffer integration for Mezzanine CMSDocumentation-------------The full documentation is at https://mezzanine-buffer.readthedocs.org.Quickstart----------This assumes you already have a Mezzanine_ install... _Mezzanine: http://mezzanine.jupo.orgInstall mezzanine-buffer::pip install mezzanine-buffer  --process-dependency-linksUnfortunately, the process-dependency-links is required until buffer-python is updated on pypi.Then use it in a project:- Add the following to your installed_apps::"mezzanine_buffer"- Create a Buffer_ account (if you don't have one already).. _Buffer: http://buffer.com- Create a `Buffer App`_ for your Mezzanine site.  You will receive an email with your client key, client secret,and access token.. _Buffer App: https://buffer.com/developers/apps/create- Enter your client key, client secret, and access token into your Mezzanine site settings.Features--------- Adds a list of your Buffer profiles to the status section of any `Displayable` admin.- If the publish_date of `Displayable` is in the future, it will be scheduled for that time.TODO----- tests- proper multi-profile support (buffpy doesn't support it)- error handling (max 10 updates per profile, rate limits etc)History-------0.1.0 (2015-05-03)++++++++++++++++++* First release on PyPI.
Package: mezzanine-careers
Mezzanine Careers is a simple Job Posting application built for theDjangobased CMSMezzanine.This app is NOT ready for production use but play as you will. It’s pretty basic.FeaturesCreate a list of job posting with delayed and expiring durationsProvide basic templates to get startedSeamlessly integrate with the Mezzanine CMSInstallation and UsageInstall the app by usingpip:$ pip install mezzanine-careersAddcareerstoINSTALLED_APPSand synchronize/migrate the database.Go to the admin site and create new job posts in theCareerssectionDevelopmentNew features and fixes are welcome. Better if it comes with a patch or pull request.
You can find the latest development sources atGitHub.
Issues are tracked at the GitHub project page.To-Doadd user posting form modelled or integrate mezzanine formsadd user uploads (resumes, CVs, portfolio, etc.)add user email replies
Package: mezzanine-donate
DescriptionA plugin for creating simple donation pages in Mezzanine that uses Stripe
for Credit Card processing.InstallationYou can install the plugin by using pip:$ pip install mezzanine-donateor, manually, by calling setup.py:$ python setup.py installSetupMake sure that you set up thesettings.STRIPE_API_KEYto your private
Stripe key.
Package: mezzanine-dpaste
MezzPaste is aMezzanineapp that integrates the Django pastebindpasteinto the Mezzanine framework.UsageFirst install the package and dependencies usingpip:pip install mezzanine-dpasteAdd the packages to yourINSTALLED_APPS, it is important to listmezzpasteabove thedpasteapp:INSTALLED_APPS = (
    # ...

    'mptt',
    'mezzpaste',
    'dpaste',
)Include thedpaste.urlsin your Mezzanine project’surls.py, abovemezzanine.urls:urlpatterns += patterns('',
    ("^pastes/", include('dpaste.urls.dpaste')),
    ("^", include("mezzanine.urls")),
)Add a cron job to purge expired pastes:30 * * * * /path/to/virtualenv/bin/python /path/to/project/manage.py cleanup_snippets > /dev/nullTo enable syntax highlighting, generate a pygments CSS file and include it in
yourbase.html:pygmentize -S default -f html -a highlight > pygments.cssYou can specify the CSS class used by the templates via theMEZZPASTE_PYGMENTS_CSSsetting:MEZZPASTE_PYGMENTS_CSS = 'codehilite'If you want to include a link in a Navigation menu, create a Page in Mezzanine
with the same URL as the mezzpaste URL you added to your project’surls.py.For additional configuration settings, see thedpaste Documentation.
Package: mezzanine-facebook-feed
Mezzanine Facebook FeedConnect Mezzanine sites to Facebook feedsInstallationInstall via pip:pip install mezzanine-facebook-feed.Addfbfeedto yourINSTALLED_APPS.Run migrations.UsageAdd Facebook App credentialsAdd your Facebook App ID and Secret to Mezzanine's setting page. Configure your App with a redirect URI of<your domain>/admin/fbfeed/access/redirect/.Create an Access instanceTo access Facebook you need to create access tokens so Mezzanine can run queries on your behalf. To create access tokens visit your admin site and clickFB Feed > Access.Create an Access instance and give it a name (this is arbitrary and for your use only).Set Facebook ID to the numeric ID of the user or page you want to query. If you want to query your own data, enter "me".Save the Access instance and open it again in the admin.Click the "Get Access Token" button in the upper-right corner.You will be redirected to Facebook. Complete the login process.If everything goes well, you'll see the access token in the Access admin page.Otherwise an error message will be shown on the top of the admin site.Display your data in templates{%loadfbfeed_tags%}{%fbfeed_photosasphotos%}{%forphotoinphotos%}<a href="{{photo.link}}"><img src="{{photo.images.0.source}}" alt="{{photo.alt_text}}"></a>{%endfor%}ContributingReview contribution guidelines atCONTRIBUTING.md.
Package: mezzanine-faq
Frequently Asked Questions page made simple.Quick startInstall the appAddmezzanine_faqin yourINSTALLED_APPSRunpython manage.py syncdbto create new database tablesUsageFirst create page of type “faq” in Mezzanine admin interface.Include FAQYou can also include FAQ on another page.{%loadfaq_tags%}# Create list of page with title "myfaq"{%faq_listtitle="myfaq"%}
Package: mezzanine-file-collections
# Mezzanine File CollectionsMezzanine File Collection is a simple file container page type for the
Django / Mezzanine CMS.The Mezzanine’s core gallery module only deals with images. I got frustrated
with it, I quickly developed an alternative to handle any filetype.Most of this app’s code is directly inspired from the Mezzanine’s core.## InstallationInstallation is quite simple.$ pip install mezzanine-file-collectionsAdd “mezzanine_file_collections” to your list of installed apps. Then migrate
your database. That’s it.## UsageOnce installed, just create a new “File collection”, and upload your files
the usual way.The default templates uses Bootstrap’s media objects for a basic rendering,
but it’s very easy to overwrite it. Just look into the template.
Package: mezzanine-grappelli
Mezzanine-Grappelli makes Mezzanine ♥ Grappelli.For compatibility reasons, Mezzanine uses forks of Grappelli and Filebrowser,
known as grappelli-safe and filebrowser-safe.You want the awesomeness of Mezzanine with the sweetness of the latest
Grappelli version? This application does exactly that: it allows you to use the
full power of the latest vanilla versions of both Grappelli and Filebrowser in
your Mezzanine projects.InstallationFirst, install mezzanine-grappelli with pip (this will automatically install
Grappelli and Filebrowser as well):pip install mezzanine-grappelliIn yoursettings.pyfile, adapt the value ofPACKAGE_NAME_FILEBROWSERandPACKAGE_NAME_GRAPPELLI:PACKAGE_NAME_FILEBROWSER = "filebrowser"
PACKAGE_NAME_GRAPPELLI = "grappelli"Still in yoursettings.pyfile, add mezzanine_grappelli, grappelli and
filebrowser to yourINSTALLED_APPS(make sure they appear before any
mezzanine app):INSTALLED_APPS = (
    "mezzanine_grappelli",
    PACKAGE_NAME_GRAPPELLI,
    PACKAGE_NAME_FILEBROWSER,
    ...
)Add Grappelli URLs to yoururls.pyfile:urlpatterns += patterns("",
    ...
    ("^grappelli/", include("grappelli.urls")),
    ...
)You’re done!Rough edgesThe project still being in its early days, it has a few rough edges you should
be aware of.TabularDynamicInlineAdmin doesn’t workUse classic DjangoTabularInlineinstead.Filebrowser error: “Error finding Upload-Folder (site.storage.location + site.directory). Maybe it does not exist?”That’s because Filebrowser doesn’t automatically create the uploads directory,
so just create theMEDIA_ROOT + 'uploads/'directoryFileField doesn’t workWhen usingFileFieldfields you need to put theformatin lowercase
(ie.  “image” instead of “Image”) otherwise you’ll get a Filebrowser exception.
That’s especially true for already defined Mezzanine models (such as theBlogPostmodel). To fix the issue for already-defined Mezzanine models, you
can add the following to your settings file:FILEBROWSER_SELECT_FORMATS = {
    'File': ['Folder', 'Image', 'Document', 'Video', 'Audio'],
    'Document': ['Document'],
    'Media': ['Video', 'Audio'],
    'Image': ['Image'],
    'image': ['Image'],
}TODOMakeTabularDynamicInlineAdminwork or at least fall back to a usable
solutionBugs, contributingIf you find bugs, you’re very welcome to report them using the Github issue
tracker.
Package: mezzanine_instagram
InstallationInvirtualenv:$ pip install mezzanine_instagramConfigurationInsettings.py:INSTALLED_APPS = (
    ...
    'mezzanine_instagram',
)

DASHBOARD_TAGS = (
    ...
    ("mezzanine_tags.recent_actions", 'instagram_tags.instagram',),
)

INSTAGRAM_CLIENT_ID = os.getenv('INSTAGRAM_CLIENT_ID')
INSTAGRAM_CLIENT_SECRET = os.getenv('INSTAGRAM_CLIENT_SECRET')Inurls.py:urlpatterns = patterns(
    '',
    ("^instagram/", include("mezzanine_instagram.urls")),
    ...
)ConfigureINSTAGRAM_CLIENT_IDandINSTAGRAM_CLIENT_SECRETenvironment variables. Access Django admin, clickAuthorize Instagram.Once you’ve authorized your site you’ll be able to access/instagram/in your browser to view the feed for the authorized
user.Media StreamRequires a caching mechanism likeMemcached,DatabaseorFilesystem. Will not work withLocal-memoryorDummy.Add a tag or more to use when generating the stream by going toDashboard > Tags. Then run the provided management command to
generate the stream.$ python manage.py build_tags_streamNow you can access theMediainDashboard. At first all images
have a green outline indicating that they’ll be shown to the public.
Click on the image to exclude it from your stream (the outline will turn
red).We recommend usingcronor similar to run the management command on
a regular basis. Please be aware that Instagram limits how often you can
access their API.The curated media stream is available to the public at/instagram/tags/.
Package: mezzanine-instagram-feed
Mezzanine Instagram FeedConnect Mezzanine sites to Instagram feedsInstallationInstall via pip:pip install mezzanine-instagram-feed.Addinstagramfeedto yourINSTALLED_APPS.UsageLoad the templatetag library and pass the username you want to query to theinstagramfeed_photostemplate tag.{%loadinstagramfeed_tags%}{%instagram_posts"USERNAME HERE"asposts%}{%forpostsinpost%}<a href="https://instagram.com/p/{{post.shortcode}}"><img src="{{post.thumbnail_src}}" alt="{{post.edge_media_to_caption.edges.0.node.text}}"></a>{%endfor%}ConfigurationConfiguration variables read fromsettings.py:SettingDefaultDescriptionSCRAPERAPI_KEYNoneIf set will use scraperapi.com to proxy requests to InstagramContributingReview contribution guidelines atCONTRIBUTING.md.
Package: mezzanine-instagram-quickphotos
===================Mezzanine Quick Photos===================A Mezzanine app to store the latest photos from Instagram.Installation---------```$ pip install mezzanine-instagram-quickphotos```Configuration---------In `settings.py`:```INSTALLED_APPS = (...'mezzanine_quickphotos',)```Configure `INSTAGRAM_ACCESS_TOKEN` and `INSTAGRAM_CLIENT_SECRET` in Mezzanine admin configuration settingRegister site application in https://www.instagram.com/developer/clients/register/ and enable implicit OAuthGet ACCESS-TOKEN```https://api.instagram.com/oauth/authorize/?client_id=CLIENT-ID&redirect_uri=REDIRECT-URI&response_type=token```
Package: mezzanine-linkdump
LinkDump is a Mezzanine module that lets you create, display and track links.Example usage can be seen atSleepAnarchy.comUsageInstall the package and dependencies via pip:pip install mezzanine-linkdumpAdd thelinkdumpapp and thempttdependency to yourINSTALLED_APPS:INSTALLED_APPS = (
    # ...

    "mptt",
    "linkdump",
)Include the urls into your project’surls.py:urlpatterns += patterns('',
    ("^links/", include('linkdump.urls')),
    ("^", include("mezzanine.urls")),
)If you want a shorter link for the redirects, route the URL to thelinkdump.views.link_dump_redirectview:urlpatterns += patterns('',
    ("^links/", include('linkdump.urls')),
    (r"^l/(.*)", "linkdump.views.link_dump_redirect"),
    ("^", include("mezzanine.urls")),
)To integrate into the navigation, create a new Page withlinksas the URL.ConfigThe following settings may be specified in your project’ssettings.py:LINKDUMP_SLUG_CHOICES- Characters used for link slugs.LINKDUMP_SLUG_LENGTH- Length of generated slugs.ContributingYou can install prerequisites usingpip:pip install -r requirements.txtThe official bug tracker lives athttp://bugs.sleepanarchy.com/projects/mezzanine-linkdump/, but a github mirror
is available for pull requests athttp://github.com/prikhi/mezzanine-linkdump/.
Package: mezzanine-modal-announcements
# Mezzanine modal announcements
Popup announcements for Mezzanine websites utilizing Bootstrap modals.## Installation
*$ pip install mezzanine-modal-announcements* Add modal_announcements to the project’sINSTALLED_APPS* Add{% include “includes/announcements.html” %}to the end of base.html, just before the footer scripts.
* Run migrationspython manage.py migrate modal_announcements* Run the server
* Log into the admin and set up some announcements## Configuration
Edit the setting “Announcement frequency” in your site’s admin (Site -> Settings) to
determine how often (in minutes) a particular user will be shown the announcements.
This restriction uses cookies so if the user clears their cookies they will be
shown announcements again.Whether or not announcements show can also be configured based on the following
parameters (all optional)Start/end timeStart/end dateDay of the week (i.e. only show on Tuesdays and Thursdays)
Package: mezzanine-page-auth
Created bySimone DallaOverviewMezzanine Page Auth isMezzaninemodule for add group-level permission to
Pages.Full Documentation at:http://mezzanine_page_auth.readthedocs.org/DependenciesMezzanine Page Auth required:Mezzanine1.4+, 3.+InstallationThe easiest method is to install directly from pypi usingpipby
running the command below, which will also install the required
dependencies mentioned above:$ pip install mezzanine_page_authIf you prefer, you can download mezzanine-auth-pages and install it directly from
source:$ python setup.py installAddmezzanine_page_authto yourINSTALLED_APPSsetting before all
mezzanine apps:INSTALLED_APPS = (
    # ...
    'mezzanine_page_auth',
    'mezzanine.boot',
    'mezzanine.conf',
    'mezzanine.core',
    # ...
)You will then want to create the necessary tables. If you are usingSouthfor schema migrations, you’ll want to:$ python manage.py migrate mezzanine_page_authMiddlewareEnablePageAuthMiddlewaremiddleware in your settings module as follows:MIDDLEWARE_CLASSES = (
    # ...
    "mezzanine.core.middleware..."
    "mezzanine.pages.middleware..."
    "mezzanine_page_auth.middleware.PageAuthMiddleware",
    # ...
)The order ofMIDDLEWARE_CLASSESis important. You should include thePageAuthMiddlewaremiddleware after other Mezzanine middlewares in the list.Template Context ProcessorsEnablepage_authtemplate context processors in your settings module as follows:TEMPLATE_CONTEXT_PROCESSORS = (
    # ...
    "mezzanine_page_auth.context_processors.page_auth",
)The order ofMIDDLEWARE_CLASSESis important. You should include thePageAuthMiddlewaremiddleware after other Mezzanine middlewares in the list.Mezzanine SettingsConfigureEXTRA_MODEL_FIELDSMezzanine setting in your settings module as
follows:EXTRA_MODEL_FIELDS = (
    # ...
    (
        "mezzanine.pages.models.Page.groups",
        "ManyToManyField",
        ("auth.Group",),
        {"blank": True, "null": True, "verbose_name": 'groups',
         'symmetrical': False, 'through': "mezzanine_page_auth.PageAuthGroup"},
    ),
    # ...
)for inject fieldgroupsinto Mezzanine’s models (reference toField InjectionMezzanine documantation).LicenseMezzanine Page Auth isBSD licensed.