Saravanan666/pypi-org huggingface dataset:
Package: django-meetup-auth
Django-Meetup-Auth==============================Django-Meetup-Auth is an extension to `Django-Social-Auth <https://github.com/omab/django-social-auth>`_which adds a backend for Meetup.com.Requirements-------------------------------- Django-Social-Auth >= 0.3.3- Django >= 1.2.5- Python-OAuth2 >= 1.5.167- Python-Openid >= 2.2API Keys-------------------------------In order to use this application you must sign up for OAuth consumer key onMeetup.com. These should be put into your settings file using the settings::MEETUP_CONSUMER_KEY = '' # Your consumer keyMEETUP_CONSUMER_SECRET = '' # Your consumer secret.. versionadded:: 0.2Django-Meetup-Auth uses the OAuth 2.0 endpoints which means you must include aRedirect URI when registering your applicaion with Meetup.com. For more detailplease see the `Meetup API documentation <http://www.meetup.com/meetup_api/auth/#oauth2server-auth-success>`_.Installation-------------------------------To install django-meetup-auth via pip::pip install django-meetup-authOr you can from the latest version from Github manually::git clone git://github.com/mlavin/django-meetup-auth.gitcd django-meetup-authpython setup.py installor via pip::pip install -e git+https://github.com/mlavin/django-meetup-auth.gitOnce you have the app installed you must include in your settings::INSTALLED_APPS = (...'social_auth','meetup_auth',...)AUTHENTICATION_BACKENDS = (...'meetup_auth.backend.MeetupBackend',...)SOCIAL_AUTH_IMPORT_BACKENDS = (...'meetup_auth',...)Please refer to the `Django-Social-Auth <http://django-social-auth.readthedocs.org/>`_documentation for additional information.Questions or Issues?-------------------------------If you have questions, issues or requests for improvements please let me know on`Github <https://github.com/mlavin/django-meetup-auth/issues>`_.
Package: django-meili
Django-MeiliA package to integrate Meilisearch with Django in a seamless way.UsageSet the following variables insettings.py.MEILISEARCH={"HOST":"localhost","PORT":7700,"HTTPS":False,"MASTER_KEY":"...","SYNC":False,# Should Meilisearch action resolve before continuing}Register the app inINSTALLED_APPSINSTALLED_APPS=[...,"django_meili",...,]Just subclassdjango_meili.models.IndexMixinfromdjango_meili.modelsimportIndexMixinclassPost(IndexMixin,models.Model):id=models.UUIDField()title=models.CharField(max_length=255)body=models.TextField()# Attributes to handle in Meilisearchdisplayed_fields=("title","body")searchable_fields=("title","body")def__str__(self):returnself.titleThen when you are ready to search this model, just use the built-in "queryset".Post.objects.create(title="Hello",body="World")posts=Post.meilisearch.search("hello")# Returns a Django Queryset of resultsprint(posts.first())# HelloAPIdjango_meili.models.IndexQuerySetThis is a custom queryset built to mimic Django's queryset. Currently does not supportQobjects, but that is a plan for the future.Methods:NameDescriptionExamplegetitemUse slices to set limit and offset. The default is 20 and 0 respectively.Post.meilisearch[:10]countReturn the total number of documents within the index.Does not reflect the count for the search queryPost.meilisearch.count()order_byTakes a Djangoorder_byparameter and sets a sort value based on that. Can take multiple sortsPost.meilisearch.order_by("-likes")filterTakes a Django filter query. Supports:lte,gte,lt,gt,exact,in,range,isnull,existsPost.meilisearch.filter(title__exact="Hello World")matching_strategySet the default strategy. Defaults tolastPost.meilisearch.matching_strategy('all')attributes_to_search_onChoose what fields to search on, defaults to all.Post.meilisearch.attributes_to_search_on("title", "body")searchExecutes the actual search. Takes an optional query and returns a Django Queryset of resultsPost.meilisearch.search()django_meili.models.IndexMixinSubclass Parameters:NameTypeDescriptionindex_nameOptional[str]The name of the index to generate. Defaults to__name__attribute.primary_keyOptional[str]The primary key of the index. Defaults topk.Attributes:NameTypeDescriptiondisplayed_fieldstuple[str]The fields to display. By default uses all.searchable_fieldstuple[str]The fields to search. By default uses all.filterable_fieldstuple[str]The fields to filter. By default uses none.meilisearchdjango_meili.models.IndexQuerySetThe queryset used for filtering and searchingCopyright 2024 Ian Kollipara <ian.kollipara@cune.edu>
Package: django-meio-easytags
django-meio-easytagsAn easy way to create custom template tags for Django’s templating system.UsageJust instantiate EasyLibrary and register the renderer method as a template tag:from easytags import EasyLibrary

register = EasyLibrary()

def sum(context, arg1, arg2, arg3=0):
    return int(arg1) + int(arg2) + int(arg3)

register.easytag(sum)The EasyLibrary will take care of subclassing EasyNode that will take care of
the template tag’s parsing, resolving variable and inspecting if the args are
ok with the renderer signature. In the example above, you can use
the sum tag in any of the forms below:{% sum "1" "2" %}
{% sum "1" arg2="2" %}
{% sum arg1="1" arg2="2" %}
{% sum arg2="2" arg1="1" %}It’s almost like calling methods in Python.In this example,arg3is optional and defaults to 0. So you may use or not this arg.
Package: django-members-roles
# django-members-roles[![Build Status](https://travis-ci.org/cowhite/django-members-roles.svg?branch=master)](https://travis-ci.org/cowhite/django-members-roles)
[![Coverage Status](https://coveralls.io/repos/github/cowhite/django-members-roles/badge.svg?branch=master)](https://coveralls.io/github/cowhite/django-members-roles?branch=master)
Package: django-memcache-admin
Memcache administration tools for Django.Show cluster information, optionally auto-updated.Show a server’s statistics.Show a server’s slabs.Flush the cluster (GUI and CLI).Compatible with default admin and Bootstrap.InstallInstall via pip:pip install django-memcache-adminAddmemcache_admintoINSTALLED_APPSin yoursettings.pyfile.Update the database:python manage.py syncdbThe application will now be available in the admin panel.PermissionsTo use this module, a user must have access to the Django admin panel and havechangepermissions on thememcache_admin | Memcache Dashboardmodel.Settingaddordeletepermissions has no effect, they are always false.SettingsIn yoursettings.pyfile, you can add a dictionary calledMEMCACHE_ADMIN.The following key/value settings are available:REFRESH_RATE — integerSets the auto-update refresh rate in milliseconds for the server information in the dashboard.
Note that auto-updating must still be activated in the dashboard for this to take effect.
If set toNone, refreshing will be disabled (unavailable in the dashboard interface).
Default is 5000 milliseconds (5 seconds).CACHE — stringThe cache definition to use. Default is “default”.CommandsAvailable management commands.flushmemcacheInvalidates all existing memcache items, so that occupied memory will be overwritten by new items.CompatibilityTested on Django 1.6 and 1.7For best results,python-memcachedshould be used.pylibmccan be used, but not all information will be available.This library is compatible with python 2 and 3, however the memcache packages above are only python2 compatible.AcknowledgementsSome ideas taken from thedjango-memcache-statusanddjango-memcached2projectsLicenseGNU Lesser General Public License, version 3.
Package: django-memcached
This is a very simple reusable app which does one thing: shows you statistics
about your currently running memcached instances.  There are no database models
and not much configuration.Installing django-memcachedEither download the tarball and runpython setup.py install, or simply
use easy install or pip like soeasy_installdjango-memcached.Add django_memcached to yourINSTALLED_APPSsetting:INSTALLED_APPS = (
    # ...
    'django_memcached',
)Add the urls to your url configuration:urlpatterns = patterns('',
    # ...
    (r'^cache/', include('django_memcached.urls')),
)If you want to restrict these urls to only staff members, just add this
setting to your settings file:DJANGO_MEMCACHED_REQUIRE_STAFF = TrueThat’s it.  Hopefully this app gives you a little insight into how your
memcached servers are being utilized.
Package: django-memcached2
django-memcached2 is a lightweight, resuable Django app that displays
statistics about your currently running memcached instances.It is a fork of Eric Florenzano’sdjango-memcachedthat works with the
CACHES settings introduced in Django 1.3.Installing django-memcached2Either download the tarball and runpython setup.py install, or simply
use easy_install or pip like soeasy_installdjango-memcached2.Add django_memcached to yourINSTALLED_APPSsetting:INSTALLED_APPS = (
    # ...
    'django_memcached',
)Add the urls to your url configuration:urlpatterns = patterns('',
    # ...
    (r'^cache/', include('django_memcached.urls')),
)If you want to restrict these urls to only staff members, just add this
setting to your settings file:DJANGO_MEMCACHED_REQUIRE_STAFF = TrueThat’s it.  Hopefully this app gives you a little insight into how your
memcached servers are being utilized.
Package: django-memcached-consul
django-memcached-consulDjango-memcached-consul helps use consul for memcached servers.
It will query Consul Health API to get list of servers every time we use the cache.UsageThe configuration is done in the cache part of local_settings.py in the Django project.
Django-memcached-consul use the Django memcached driver so all configuration related to the
caching itself should be done like in django memcached.To use consul you need to use the specific Django-memcached-consul driver:django-consul-memcached.memcached.MemcachedCacheAnd to provide informations about Consul and the required services:CONSUL_HOST # The Consul API host
CONSUL_PORT # The Consul API port
CONSUL_SERVICE # The service of the memcached servers in ConsulIt is possible and strongly recommended to use a cache for the consul, otherwise an Consul API call
will be issued every time we use the cache.Django-memcached-consul use two layer of cache: the first layer should be short lived (CONSUL_TTL)
and is used to cache the list of memcached servers and is retrieved everytime we use the
django-consul-memcached driver. The second one is long lived (CONSUL_TTL_ALT) and retrieved when
Consul API is unreachable. The name of the cache to be used is set inCONSUL_CACHEand the cache
should be preferably a filebased cache to be shared accross all workers.ExampleCACHES = {
    'default': {
        'BACKEND': 'django_memcached_consul.memcached.MemcachedCache',
        'TIMEOUT': 60,
        'CONSUL_TTL': 60,
        # Alt cache will be used if consul is unreachable
        'CONSUL_ALT_TTL': 3600,
        'CONSUL_CACHE': 'consul-memcached',
        'CONSUL_HOST': 'consul.organization.com',
        'CONSUL_PORT': 8500,
        'CONSUL_SERVICE': 'memcached-service',
    },
    'consul-memcached': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': '/var/tmp/django_consul_cache',
    }
}TestingTesting require memcached and tox.First you need to run memcached on default configuration (usually at localhost:11211) or you will
have to change informations intests/tests_data/consul_api_health_mock_with_memcached.json).Then you can run tox at the root of the project to start the tests:tox
Package: django-memcached-hashring
A simple Django cache backend based onpython-memcachedusinghash_ringfor consistent hashes. See the individual packages’ documentation for more
info.Use it like this:CACHES = {
    'default': {
        'BACKEND': 'memcached_hashring.backend.MemcachedHashRingCache',
        'LOCATION': [
           '10.0.0.1:11211',
           '10.0.0.2:11211',
           '10.0.0.3:11211',
        ],
    },
}
Package: django-memcachedkeys
Memcached has some weird rules about its keys. Ignore them and you’ll get an
error like “MemcachedKeyCharacterError: Control characters not allowed”. So
install this.QuickstartInstall django-memcachedkeys:pip install django-memcachedkeysThen use it in your settings file:CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
        'KEY_PREFIX': 'whatever',
        'KEY_FUNCTION': 'memcachedkeys.make_key',
    }
}
Package: django-memcached-pool
django-memcached-pool=====================An efficient fast Django Memcached backend with a pool of connectors, based onultramemcache.See https://github.com/esnme/ultramemcacheEach connection added in the pool stays connected to Memcache or Membase,drastically limiting the number of reconnections and open sockets yourapplication will use on high load.If you configure more than one Memcache server, each new connectionwill randomly pick one.Everytime a socket timeout occurs on a server, it's blacklisted sonew connections avoid picking it for a while.To use this backend, make sure the package is installed in your environmentthen use `memcachepool.cache.UMemcacheCache` as backend in your settings.**Also, make sure you use umemcache >= 1.5**Here's an example::CACHES = {'default': {'BACKEND': 'memcachepool.cache.UMemcacheCache','LOCATION': '127.0.0.1:11211','OPTIONS': {'MAX_POOL_SIZE': 100,'BLACKLIST_TIME': 20,'SOCKET_TIMEOUT': 5,'MAX_ITEM_SIZE': 1000*100,}}}Options:- **MAX_POOL_SIZE:** -- The maximum number of connectors in the pool. default: 35.- **BLACKLIST_TIME** -- The time in seconds a server stays in the blacklist. default: 60- **SOCKET_TIMEOUT** -- the time in seconds for the socket timeout. default: 4- **MAX_ITEM_SIZE** -- The maximum size for an item in Memcache.2013-12-13 - 0.4################- Use pickle.HIGHEST_PROTOCOL #8-.....2012-10-05 - 0.3.1##################- fixed cache.clear- make sure timeout=0 is treated as infinite2012-10-05 - 0.3################- now based on umemcache 0.5- added support for MAX_ITEM_SIZE2012-09-07 - 0.2################- Added the licence info2012-08-28 - 0.1################- Initial release
Package: django-memcached-pool-gto
django-memcached-pool=====================**This is a maintained version of Mozilla django-memcached-pool**An efficient fast Django Memcached backend with a pool of connectors, based onultramemcache.See https://github.com/esnme/ultramemcacheEach connection added in the pool stays connected to Memcache or Membase,drastically limiting the number of reconnections and open sockets yourapplication will use on high load.If you configure more than one Memcache server, each new connectionwill randomly pick one.Everytime a socket timeout occurs on a server, it's blacklisted sonew connections avoid picking it for a while.To use this backend, make sure the package is installed in your environmentthen use `memcachepool.cache.UMemcacheCache` as backend in your settings.**Also, make sure you use umemcache >= 1.5**Here's an example::CACHES = {'default': {'BACKEND': 'memcachepool.cache.UMemcacheCache','LOCATION': '127.0.0.1:11211','OPTIONS': {'MAX_POOL_SIZE': 100,'BLACKLIST_TIME': 20,'SOCKET_TIMEOUT': 5,'MAX_ITEM_SIZE': 1000*100,}}}Options:- **MAX_POOL_SIZE:** -- The maximum number of connectors in the pool. default: 35.- **BLACKLIST_TIME** -- The time in seconds a server stays in the blacklist. default: 60- **SOCKET_TIMEOUT** -- the time in seconds for the socket timeout. default: 4- **MAX_ITEM_SIZE** -- The maximum size for an item in Memcache.2016-08-24 - 0.6################- rename _get_memcache_timeout to get_backend_timeout for Django >1.9- add function bug fix2013-12-13 - 0.4################- Use pickle.HIGHEST_PROTOCOL #8-.....2012-10-05 - 0.3.1##################- fixed cache.clear- make sure timeout=0 is treated as infinite2012-10-05 - 0.3################- now based on umemcache 0.5- added support for MAX_ITEM_SIZE2012-09-07 - 0.2################- Added the licence info2012-08-28 - 0.1################- Initial release
Package: django-memdb
Django Memory DatabaseWhat is it?A library that allows tables to be kept in an in-memory database and optionally
can provide persistence between instance restart by spooling the tables to a
table that is read upon startup to populate the in-memory tables.What problem does it solve?Create in-memory tables with optional data persistence.How do I install it?pipinstalldjango-memdbAdding to Django (using integrator)# At the bottom of your settings.py file.importdjango_integratordjango_integrator.add_application('django_memdb')If you don’t want to use the above, add the application to INSTALLED_APPS and
merge the apps settings.py and url.py into the django projects files.How do I use it?When defining models, use the class mixin.For example:fromdjango.dbimportmodelsfromdjango_memdb.mixinsimportInMemoryDB,PeristentInMemoryDBclassTestModelWithMixin(models.Model,InMemoryDB):text=models.TextField()classTestModelPersistent(models.Model,PeristentInMemoryDB):text=models.TextField()Both mixins work more like a tag, which is used to determine if a table is an
in-memory table or not and if the table contents should be stored in the
(using the default database) PersistentStorage model.You can optionally hook into the persistentstorage mechanics by attaching to the
signals this app provides. The below example will add compression the data
before storing it:fromdjango_memdbimportsignalsdefcompress(arguments):"Compress data."# pylint: disable=redefined-variable-typeifarguments['process']==settings.MEMDB_PROCESS_ENCODE:data=arguments['data']data=json.dumps(data)data=data.encode('utf-8')data=zlib.compress(data)arguments['data']=dataelifarguments['process']==settings.MEMDB_PROCESS_DECODE:data=arguments['data']data=zlib.decompress(data)data=data.decode('utf-8')data=json.loads(data)arguments['data']=datadefcallback(sender,**kwargs):# pylint: disable=unused-argument"Just insert a hook."kwargs['kwargs']['processors'].append(compress)signals.store_save.connect(callback)signals.store_load.connect(callback)CaveatThe in memory database is local to each server instance, thus if you have a
setup that uses multiple servers and a single django database instance, you will
have synchronisation issues with the in-memory data and hard conflicts when
using the persistent storage.What license is this?Two-clause BSDHow can I get support?Please use the repo’s bug tracker to leave behind any questions, feedback,
suggestions and comments. I will handle them depending on my time and what looks
interesting. If you require guaranteed support please contact me via
e-mail so we can discuss appropriate compensation.Signing OffIs my work helpful or valuable to you? You can repay me by donating via:https://paypal.me/MartinHellwig-or-https://www.patreon.com/hellwigThank you!
Package: django-memento-framework
# django-memento-frameworkA set for helpers for Django web sites to enable [the Memento framework](http://timetravel.mementoweb.org/about/) for time-based access[![Build Status](https://travis-ci.org/pastpages/django-memento-framework.png?branch=master)](https://travis-ci.org/pastpages/django-memento-framework)
[![PyPI version](https://badge.fury.io/py/django-memento-framework.png)](http://badge.fury.io/py/django-memento-framework)
[![Coverage Status](https://coveralls.io/repos/pastpages/django-memento-framework/badge.png?branch=master)](https://coveralls.io/r/pastpages/django-memento-framework?branch=master)
[![Documentation Status](https://readthedocs.org/projects/django-memento-framework/badge/?version=latest)](https://readthedocs.org/projects/django-memento-framework/?badge=latest)Documentation: [django-memento-framework.rtfd.org](http://django-memento-framework.rtfd.org)Issues: [github.com/pastpages/django-memento-framework/issues](https://github.com/pastpages/django-memento-framework/issues)Packaging: [pypi.python.org/pypi/django-memento-framework](https://pypi.python.org/pypi/django-memento-framework)Testing: [travis-ci.org/pastpages/django-memento-framework](https://travis-ci.org/pastpages/django-memento-framework)Coverage: [coveralls.io/r/pastpages/django-memento-framework](https://coveralls.io/r/pastpages/django-memento-framework)
Package: django-memorize
Writing a flashcard application is almost a rite of passage for django users.You create a simple Card model, you create a quiz view and template and you callit a day. A simple application and not very useful.Django-memorize adds a more advanced way of learning your flashcards (orwhatever items you'd like) with the theory of `spaced repetition<http://en.wikipedia.org/wiki/Spaced_repetition spaced repetition>`_. The`SuperMemo 2 algorithm <http://www.supermemo.com/english/ol/sm2.htm>`_ iscurrently used. Flashcard web apps have just gotten better and easier.Installation============#. Download the `latest version<http://code.google.com/p/django-memorize/downloads/list>`_.#. Extract and run ``python setup.py install``.#. Add ``memorize`` to ``INSTALLED_APPS`` list.Usage=====Add an Item to Practice-----------------------Let's assume you have a flashcard web app with a card model::from django.db import modelsfrom django.contrib.auth.models import Userclass Card(models.Model):front = models.CharField(max_length=255)back = models.CharField(max_length=255)user = models.ForeignKey(User)To begin practicing a new card, save a practice object for your flashcard::from memorize.models import Practicecard = Card(front="When was Sgt. Pepper released?", back="1967",user=request.user)practice = Practice(item=card, user=card.user)practice.save()Start Practicing----------------The view ``memorize.views.next_practice_item`` does all the work of determiningwhat the next item a user should practice. You just need to provide a templatefile. Add an item to your urls.py file::urlpatterns += patterns('memorize.views',url(r'^item/next/$', 'next_practice_item', {'template':'memorize/next.html'}, name='next-song'),)Template Variables Provided~~~~~~~~~~~~~~~~~~~~~~~~~~~formA ``memorize.forms.RatingsForm`` instance you use to save the performance onthis practice instance.itemYour original item. Use this to get your information (e.g., ``card.front``information)practiceThe practice row.Saving Feedback---------------The key to spaced repetition algorithms is using your past performance todetermine when is the optimal time to reshow an item. If you used the``next_practice_item`` the template will have a ``form`` object that providesall the relative information.The view ``memorize.views.process_rating`` will process the data. Add this viewto your urls.py file.Example::<form action="{% url memorize.views.process_rating %}" method="post">{{ form }}</form>
Package: django-mentions
=======django-mentions=======Facebook-like mentions for Django-----------------------------------------------------Installation""""""""""""Add aplication to INSTALLED_APPS in **settings.py**:::INSTALLED_APPS = (...,'mentions',)Add app urls to your **urls.py**:::urlpatterns = patterns('',...url(r'^mentions/', include('mentions.urls')),)Implement a mention provider:::from mentions.providers import Providerclass UserProvider(Provider):model = Userdef get_title(self, obj):return obj.usernamedef search(self, request, term):return self.get_queryset().filter(username__istartswith=term)Add this provider to your **settings.py**:::MENTIONS_PROVIDERS = {# You can put your provider anywhere you want'default': ['accounts.mentions.UserProvider']}Use `mentions.forms.MentionTextarea` widget instead of the default one:::from mentions.forms import MentionTextareaclass PostForm(forms.ModelForm):class Meta:model = Postwidgets = {'text': MentionTextarea}To urlize mentions in your templates, use `urlize_mentions` filter:::{{ post.text|urlize_mentions }}
Package: django-mentor-components
django-mentor_componentscomponents collection for mentor_dsSupported components필수 컴포넌트'popup',
'base',
'hero',선택 공통 컴포넌트'counts',
'about',
'whyus',
'testimonials',
'team',
'faq',
'contact',선택 유니크 컴포넌트'courses',
'features',
'events',
'pricing',