Saravanan666/pypi-org huggingface dataset:
Package: django-gae-backends
A collection a django backends for the Google App EngineFeatures:- memcache/datastore session backend- email backend- cache backend- rdbms for migrationsTODO:- file storage base in the Google Cloud StorageSetup=====Add to the settings.py the following lines to install the backends:SESSION_ENGINE = "gae_backends.sessions.cached_db"EMAIL_BACKEND = "gae_backends.mail.EmailBackend"CACHES = {'default': {'BACKEND': 'gae_backends.memcache.MemcacheCache',}}if os.getenv('SETTINGS_MODE') == 'prod':# Running in development, but want to access the Google Cloud SQL instance# in production.DATABASES = {'default': {'ENGINE': 'gae_backends.rdbms','INSTANCE': 'your_instance:your_db','NAME': '....','USER': '....','OPTIONS': {'init_command': 'SET storage_engine=INNODB',}}}
Package: django-gaekit
=============================django-gaekit=============================Collection of backends, wrappers and utilities to enquicken django development on Google App Engine... image:: https://travis-ci.org/Beyond-Digital/django-gaekit.svg?branch=master:target: https://travis-ci.org/Beyond-Digital/django-gaekit.. image:: https://pypip.in/version/django-gaekit/badge.svg?style=flat:target: https://pypi.python.org/pypi/django-gaekit/:alt: Latest Version.. image:: https://requires.io/github/Beyond-Digital/django-gaekit/requirements.svg?branch=master:target: https://requires.io/github/Beyond-Digital/django-gaekit/requirements/?branch=master:alt: Requirements StatusDocumentation-------------The full documentation is at http://django-gaekit.rtfd.org.Features--------* Django storage backend using Google Cloud Storage* Django cache backend using Memcache* Import blacklisted modules in the SDK (eg sqlite3)History------1.0.2 (2015-04-27)++++++++++++++++++* Adds wagtail.wagtailimages integration tests* Storage.open now raises IOError if file doesn't exist* Storage.size now raises OSError if file doesn't exist1.0.1 (2015-03-24)++++++++++++++++++* Adds support for retrieving file size1.0.0 (2015-02-18)++++++++++++++++++* Remove dependency on ImageService. URLs are now constructed from bucket name, with no RPC calls.* Resolved inconsistencies with returning bucket name as part of path. This is now hidden.* Deprecated ImageService-specific options. IMAGESERVICE_DEFAULT_SIZE and IMAGESERVICE_SECURE_URLS.* Deprecated drf_extensions module.0.2.9 (2014-08-13)++++++++++++++++++* Break out options IMAGESERVICE_DEFAULT_SIZE, IMAGESERVICE_SECURE_URLS and IMAGESERVICE_UPLOAD_HEADERS0.2.8 (2014-08-13)++++++++++++++++++* Duff release0.2.7 (2014-04-17)++++++++++++++++++* Add FeedListKeyConstructor for drf_extensions0.1.4 (2014-03-10)++++++++++++++++++* Add fallback for cloud storage urls0.1.3 (2014-03-10)++++++++++++++++++* Add exception logging if URL generation fails0.1.2 (2014-03-07)++++++++++++++++++* Remove utils (lock, memoizer)* Monkeypatch ReadBuffer to add open() stub (fixes issue with easy_thumbnails)0.1.1 (2013-10-10)++++++++++++++++++* Fix for distributed lock0.1.0 (2013-08-15)++++++++++++++++++* First release on PyPI.
Package: django-ga-intl-app
forked to patch handling of international urlsDjango Google AnalyticsDjango Google Analytics brings the power of server side/non-js Google Analytics to your Django projectsContentsDjango Google AnalyticsInstallationUsage1. HTML tag2. Middleware + CeleryInstallationInstalldjango-google-analytics-appfrom PyPI or add to your Python path some other way.Addgoogle_analyticsto youINSTALLED_APPSsetting.Add URL include to your project’surls.pyfile:(r'^djga/', include('google_analytics.urls')),Specify a Google Analyticstracking code, i.e.:GOOGLE_ANALYTICS = {
    'google_analytics_id': 'xxx',
}wherexxxis your tracking code.If you intend tracking through middleware and Celery remember toinstall Celery and run its worker process.UsageThere are two ways to add tracking to your pages.1. HTML tagUsing<img/>and sticking it in yourbase.html:{% load google_analytics_tags %}
<div style="display:none">
    <img src="{% google_analytics %}" width="0" height="0" />
</div>2. Middleware + CeleryUsing Django’s middleware, you can process every request and use Celery to make the request to Google Analytics:MIDDLEWARE_CLASSES = (
    'google_analytics.middleware.GoogleAnalyticsMiddleware',
)You have to addgoogle_analyticsto yourCELERY_IMPORTS:CELERY_IMPORTS = ('google_analytics.tasks')You can also specify paths that will be excluded when tracking:GOOGLE_ANALYTICS_IGNORE_PATH = ['/health/', ]
Package: django-galaxy
Django interfacing with Galaxy. Backend using the bioblend API.Galaxyis a web based workflow platform that can be used to perform bioinformatics in a reproducible and sharable environment.Further documentation available onReadTheDocsQuick startAdd “galaxy” and django application dependencies to your INSTALLED_APPS setting like this (galaxy should come before gfiles):INSTALLED_APPS = [
    ...
    'galaxy',
    'gfiles',


    'django_tables2',
    'bootstrap3',
    'django_tables2_column_shifter',
    'django_sb_admin',
    'django_filter'
]Include the polls URLconf in your project urls.py like this:url(r'^', include('gfiles.urls')),
url('galaxy/', include('galaxy.urls')),Runpython manage.py migrateto create the models.Start the development server and visithttp://127.0.0.1:8000Registerhttp://127.0.0.1:8000/register/and loginhttp://127.0.0.1:8000/login/View summary of Galaxy instances and optionshttp://127.0.0.1:8000/galaxy/galaxy_summary/Register Galaxy instancehttp://127.0.0.1:8000/galaxy/addgi/Register Galaxy userhttp://127.0.0.1:8000/galaxy/addguser/Upload file(s) to Django (for bulk upload of files see django-misa and django-mogi)http://127.0.0.1:8000/upload_gfile/Upload file(s) to Galaxy data library (for bulk upload of files see django-misa and django-mogi)http://127.0.0.1:8000/galaxy/files_to_galaxy_datalib/Run workflow (for running workflows with ISA data see django-misa and django-mogi)http://127.0.0.1:8000/galaxy/workflow_summary/View historieshttp://127.0.0.1:8000/galaxy/history_status/
Package: django-galicia
Country-specific Django helpers for Galicia (Spain), as in django-localflavor.What is django-galicia?For now, it’s just a couple of form widgets:GaliciaMunicipalitySelect: ASelectwidget that uses a list of Galician
municipalities as its choices.GaliciaProvinceSelect:A Selectwidget that uses a list of Galician
provinces as its choices.GaliciaComarcaSelect:A Selectwidget that uses a list of Galician comarcas
as its choices.
Package: django-galleries
A set of utilities for creating gallery models and admin classes.Example:models.pyDefine models for all of the types you want to put in your gallery, then create
aGallerysubclass that specifies which models to allow for its members.Attention!In older versions, we recommended that you extend django-gallery’s includedImageModelorEmbedModelclasses if your gallery contained those
types. Those models are now deprecated. Just define your own!fromgalleries.modelsimportGalleryfromimagekit.modelsimportImageSpecfromimagekit.processorsimportCropclassYouTubeVideo(models.Model):title=models.CharField(max_length=50)embed_code=models.TextField()thumbnail=models.ProcessedImageField([Crop(60,60)],upload_to='gallery_posters')classPhoto(models.Model)title=models.CharField(max_length=50)description=models.CharField(max_length=255,blank=True)original_image=models.ImageField(upload_to='galleries')thumbnail=models.ImageSpec([Crop(60,60)],image_field='original_image')classApartmentGallery(Gallery):classGalleryMeta:member_models=[Photo,YouTubeVideo]The gallery class will automatically create a membership (through) model, which
will be accessible atApartmentGallery.Membership.admin.pyfrom.modelsimportApartmentGalleryfromgalleries.adminimportregister_gallery_adminregister_gallery_admin(ApartmentGallery)settings.pyINSTALLED_APPS=('imagekit',...)This should register you new app with our galleries models and include the
thumbnail preview.
Package: django-gallery-ds
django-gallery_dsdjango-gallery_ds is a Django app to use for demiansoft.Quick startAdd "gallery" to your INSTALLED_APPS setting like thisINSTALLED_APPS=[...'gallery',]코드를 넣고자 하는 위치에 다음을 추가 한다.{% load gallery_tags %}
{% make_gallery %}context examplecontext={"theme":"mentor_ds","gallery":{"title":"Gallery","desc":"Photos from Our Clinic",}}static - img/gallery/ 폴더내에 동일한 크기(800x600, 세로사진은 안됨)의 jpg 파일을 인식하여 보여줌지원 템플릿 - bethany_ds, medilab_ds
Package: django-galleryfield
Django model fieldsGalleryFieldwith AJAX form widgets and for multiple images upload with progress bar.
This package isNOTabout how to elegantly render multiple images in a page, but how to CRUD multiple
images in a model field, which makes it possible for easy permission control.FeaturesA model fieldGalleryField, and its formfieldGalleryFormFieldalong with the default widgetGalleryWidget.Drag & drop file uploading via AJAXUploading multiple images with progress barDrag & drop reordering, client / server side crop before/after upload.Integrates with Django Admin.Each Image uploaded will be saved in an image model. That might be considered, by some user,
a draw back. However, that makes it possible to delete theorphanimages from the server (see in FAQ).ScreenShotsMultiple image upload, sortableClient/Server side cropEasy Gallery renderQuick StartRequirementsDjango 3.1 or latersorl-thumbnailpillow(or PIL)Installpip install django-galleryfieldUsageInsettings.py, add 3 lines in youINSTALLED_APP:INSTALLED_APPS = (
    ...,
    'sorl.thumbnail',
    'galleryfield',
    ...,
)

DJANGO_GALLERY_CONFIG = ...Inurls.py, add the following lines:from django.urls import include, path

urlpatterns += [path(r"gallery-handler/", include("galleryfield.urls"))]
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)Run the demogit clone https://github.com/dzhuang/django-galleryfield.git
cd django-galleryfield
cd demo
pip install -r requirements.txt
cd ..
python manage.py migrate
python manage.py createsuperuser # Create a superuser account so that you can upload images
python manage.py runserverIn your browser navigate tohttp://127.0.0.1:8000/admin, login and navigate tohttp://127.0.0.1:8000/.NoteYou might need to install JSON1 extension for SQLite for this the demo to run properly. SeeEnabling JSON1 extension on SQLite.Online documentationPlease visithttps://django-galleryfield.readthedocs.iofor the documentation.Contribute to the projectSeeContribution guide.LicenseReleased under theMIT license.
Package: django-ga-mail
A reusable Django app that sends google analytics report by email.InstallationTo get the latest stable release from PyPi$pipinstalldjango-ga-mailTo get the latest commit from GitHub$pipinstall-egit+git://github.com/nanvel/django-ga-mail.git#egg=ga_mailAddga_mailto yourINSTALLED_APPSINSTALLED_APPS=(...,'ga_mail',)Specify next variables in settings:GA_PROFILE_ID=12345678GA_USERNAME='some.user@gmail.com'# don't use your working account here,# create another one for analytics and give it access to ga profileGA_PASSWORD='somepass'GA_SOURCE_APP_NAME='some.site',ANALYTICS_BLOCKS=('new_visitors_30days_today','new_visitors_7days_today_vs_14days_7days','pageviews_7days_today')Check that MANAGERS variable contains necessary emails.Available blocks:returning_visitors_7days_todaynew_visitors_7days_todaynew_visitors_30days_todaynew_visitors_7days_today_vs_14days_7daysnew_visitors_7days_today_vs_returning_visitors_7days_todaypageviews_7days_todaycountries_30days_todayCallpython manage.py ga_mailto send analytics report.ContributeIf you want to contribute to this project, please perform the following steps# Fork this repository
# Clone your fork$virtualenv.env--no-site-packages$source.env/bin/activate$pythonsetup.pyinstall$pipinstall-rtest_requirements.txt$gitco-bfeature_branchmaster# Implement your feature and tests$gitadd.&&gitcommit$gitpush-uoriginfeature_branch# Send us a pull request for your feature branch
Package: django-ga-measurement-protocol
Django Google Analytics Measurement Protocol integrationUsageInstallationpipinstalldjango-ga-measurement-protocolMiddlewareThe most basic usage is to install the page view middleware:MIDDLEWARE=[..."django_ga_measurement_protocol.middleware.page_view_tracking_middleware",...]and configure the required settings:GA_MEASUREMENT_PROTOCOL_UA="<tracking id>"# The tracking id for your propertyGA_MEASUREMENT_PROTOCOL_TRACK_EVENTS=True# By default the package won't do any tracking unless explicitly setAdditional functionsThere are additional functions that allow for custom tracking beyond what the the middleware provides.fromdjango_ga_measurement_protocol.trackimport(track_event,track_page_view,)defa_view(request):# Tracks an event in Google Analyticstrack_event(request,category="Category",# requiredaction="Action",# requiredlabel="Label",# optionalvalue="5",# optional)# Tracks a page view in Google Analyticstrack_page_view(request)The above functions will extract the basic required information from the Django request that is required to register an event/page view in Google Analytics.If more customisation is required there are additional functions that allow fully custom data to be sent to Google Analytics.fromdjango_ga_measurement_protocol.trackimport(build_tracking_data,send_tracking_data,)defa_view(request):# Builds tracking data with default information from the Django requesttracking_data=build_tracking_data(request,{"additional-value":"value",},)# Sends tracking data to Google analyticssend_tracking_data(tracking_data)The values that are accepted by the measurement protocol can be foundhere.DebugWhen sending data to Google Analytics, by default, nearly all data is accepted even if it is missing required data or is corrupted in some other way. However, there is a facility for Google Analytics to respond with some validation data for your events.To turn this on set the following settings:GA_MEASUREMENT_PROTOCOL_DEBUG=TrueLOGGING={...'loggers':{...'django_ga_measurement_protocol':{'level':logging.DEBUG,'handlers':['console'],},},}This will log the validation in the response returned from Google Analytics.This shouldnotbe used in production.DevelopmentInstallationIt is recommended to initialise a virtualenv of your choice.pipinstall-rrequirements.txtFormattingFormatting is done via Black and a pre-commit hook should be installed.pre-commitinstallTestsTo run the tests with the currently installed Python and Django version run:pytestTo run against all of the possible compatible Python and Django versions run:tox
Package: django-game-info
.. image:: https://travis-ci.org/Azelphur-Servers/django-game-info.svg?branch=master:target: https://travis-ci.org/Azelphur-Servers/django-game-info.. image:: https://coveralls.io/repos/Azelphur-Servers/django-game-info/badge.svg?branch=master&service=github:target: https://coveralls.io/github/Azelphur-Servers/django-game-info?branch=master.. image:: https://requires.io/github/Azelphur-Servers/django-game-info/requirements.svg?branch=master:target: https://requires.io/github/Azelphur-Servers/django-game-info/requirements/?branch=master:alt: Requirements Status=====django_game_info=====django_game_info is a Django app to collect data from game serversthat respond to the A2S protocol defined at https://developer.valvesoftware.com/wiki/Server_queriesExamples of servers that follow this protocol include::- Team Fortress 2- Counter Strike: Source- Counter Strike: Global Offensivethe module provides a json feed which you can use to display lotsof information about your servers, perfect to put in your sitessidebar.Quick start-----------1. Install with `pip install django-game-info`2. Add "game_info" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'game_info',]3. Include the game_info URLconf in your project urls.py like thisurl(r'^game_info/', include('game_info.urls')),4. Run `python manage.py migrate` to create the models5. Start the development server and visit http://127.0.0.1:8000/adminto add some servers (you'll need the Admin app enabled)6. Run `python manage.py update_game_info` to gather information fromyour game server(s)7. Visit http://127.0.0.1:8000/game_info/ to see a JSON feed of thegathered information
Package: django-ganalytics
# django-ganalyticsSimple Google Analytics integration for Django.## Meta* author: Randall Degges* email:  r@rdegges.com* status: maintained, in development[![Build Status](https://secure.travis-ci.org/rdegges/django-ganalytics.png?branch=master)](http://travis-ci.org/rdegges/django-ganalytics)## PurposeHonestly, all the other Google Analytics Django apps suck. All I want to do isput my Google Analytics code in my ``settings.py`` file, and use a simpletemplate tag to render the Google Analytics asynchronous javascript code,damnet!Unfortunately, all the existing solutions don't do this, and that pisses meoff!![squint](https://github.com/rdegges/django-ganalytics/raw/master/assets/squint.png)## Installation and UsageAnyway, let's install this bitch! The first thing you'll want to do is run:``` bash$ pip install django-ganalytics```Next, modify your ``settings.py`` file, and add your Google Analytics code(usually something like ``UA-XXXXXXXX-XX``), as well as put``ganalytics`` in your ``INSTALLED_APPS``:``` python# settings.pyINSTALLED_APPS = (# ...'ganalytics',)GANALYTICS_TRACKING_CODE = 'UA-XXXXXXXX-XX'```Now, to actually render your Google Analytics asynchronous javascript code,edit your desired Django template (I like to do this in my ``base.html``template), and add the following:``` html{% load ganalytics %}<!--- ... --><head>{% ganalytics %}</head><!--- ... -->```When Django processes your template, it'll replace ``{% ganalytics %}``with:``` html<script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,'script','//www.google-analytics.com/analytics.js','ga');ga('create', '{{ GANALYTICS_TRACKING_CODE }}', 'auto');ga('send', 'pageview');</script>```Easy, right?
Package: django-gannett-polling
Django-crowdsourcing is an MIT-licensed survey and report tool for
journalists, supporting many types of survey questions and a wide
variety of reporting options.  A reusable Django application, it is
designed to be installed easily in any Django site, including
multi-site installations.  Its surveys are entirely configured within
the admin interface that ships with Django.While the primary focus of development is support for crowdsourcing
projects, the survey tool is general purpose and can be used for a
variety of applications.  It is easy enough to handle simple polls
with pie charts, yet powerful enough to handle complicated surveys
with rich multimedia responses plotted on a map with custom icons.History/CreditsDjango-crowdsourcing began life as a fork of Doug Napoleone’sdjango-survey.  Jacob Smullyan and James Richards started the project;
Dave Smith wrote most of the 1.x version.InstallationPrerequisites are:Django itself, of course – 1.4 or better.PILdjango-positionssorl-thumbnailflickrapi(optional)Django-crowdsourcing itself can be installed withpip:$ # probably in a virtualenv ...
$ pip install django-crowdsourcingRunning The Example App$ easy_install pip$ pip install -r crowdsourcing_requirements.txt$ pip install -r example_app/example_app_requirements.txtBy default the example app will use a sqlite db; if if you want to
change that, modify example_app/example_app/settings.py accordingly.$ cd example_app$ ./manage.py syncdb$ ./manage.py runserverAdd some surveys in /admin/NotesShould work under Django 1.4Only tested on Python 2.6DocumentationExtensive documentation is included, or can be readonline.Other ResourcesPython Cheeseshop page:http://pypi.python.org/pypi/django-crowdsourcingSource code repository and ticket tracker:http://code.google.com/p/django-crowdsourcing/Discussion group:http://groups.google.com/group/django-crowdsourcing/
Package: django-gapc-storage
django-gapc-storagedjango-gapc-storageis a Django storage backend for Google Cloud Storage
using the JSON API through google-api-python-client.RequirementsDjango 1.8+SettingsSet theGCS_BUCKETenvironment variable to the GCS bucket to be used
by the storage backend.Settings can be customized via theGAPC_STORAGEsettings dict:GAPC_STORAGE = {
    "allow_overwrite": False,
    "bucket": "my-bucket",
    "cache_control": "public, max-age=3600",
    "num_retries": 0,
    "path_prefix": "",
}GAPC_STORAGE["allow_overwrite"]Default:FalseIfTrue, the storage backend will overwrite an existing object with
the same name.GAPC_STORAGE["bucket"]Default:os.environ["GCS_BUCKET"]GAPC_STORAGE["cache_control"]Default:public,max-age=3600By default, public-readable objects on GCS have a cache duration of 60
minutes.  Setcache_controltoprivate,max-age=0to disable
public caching of objects saved by the storage backend.GAPC_STORAGE["num_retries"]Default:0Passed to the supported methods on the underlying google-api-python-client client which will retry 500 error responses with randomized exponential backoff.For more information, see thegoogle-api-python-client documentation.GAPC_STORAGE["path_prefix"]Default:""A prefix appended to the path of objects saved by the storage backend.
For example, configuring path_prefix tomediawould save
objects tomy-bucket/media.
Package: django-ga-puller
django-ga-puller================Django app used to pull daily Google Analytics data into your django database. It provides abstract models which you shouldinherit from in your app.To Use------Add the app to your settings.py file:INSTALLED_APPS = [...'ga_puller',...]In your app,Create models that inherit from the abstract classes provided.  Here is a sample of a basic implementation:from ga_puller.models import AnalyticsPage, DailyEventTrackingBase, DailyPageTrackingBaseclass Page(AnalyticsPage):def __unicode__(self):return "%s" % self.page_pathclass DailyEventData(DailyEventTrackingBase):page = models.ForeignKey('Page')@classmethoddef get_page_class(cls):return Pageclass DailyPageTrackingData(DailyPageTrackingBase):page = models.ForeignKey('Page')@classmethoddef get_page_class(cls):return PageAdd a list named analytics_import_models defining the data models to the __init__.py of your app module:from models import DailyPageTrackingData, DailyEventDataanalytics_import_models = [DailyPageTrackingData, DailyEventData]Create a 'private' python package at the root level of your django project (at the same level as the manage.py file).The application requires a service account for authentication with Google.  These can be configured by logging into your account at https://cloud.google.com.Copy your Google API private key file to the private directory (name it privatekey.pem).Create a python file named 'accounts.py' in the private directory with the following code (update with your account data):service_account = 'xxxxxx@developer.gserviceaccount.com'view_ids = {'app_name': '#########', ...}This package uses [Google APIs Client Library for Python](https://developers.google.com/api-client-library/python/) which should automatically be installed through setup.Release Notes:0.1.0: Initial Release0.1.1: Updated to support importing from separate views in google analytics.0.1.2: Increased the size of the label and page_path fields.
Package: django-garcimore
Garcimoreis a famous french magician.
Have a look at this video of his bestmagic trickdjango-garcimore allow you to make django diseapear:>>> import django
>>> import garcimore
>>> import django # doctests: +ELLIPSIS
Traceback (most recent call last):
...
ImportError: No module named djangoHich hich hich !django-garcimore can be usefull if you plan to use Django on GAE or if you dont want to use Django.