Saravanan666/pypi-org huggingface dataset:
Package: django-tailwind-cli
django-tailwind-cliThis library provides an integration ofTailwind CSSfor Django that is using on the precompiled versions of theTailwind CSS CLI.The goal of this library is to provided the simplest possible Tailwind integration for your Django project. It took its inspiration from theTailwind integration for Phoenixwhich completely skips the neccesity of a node installation.InstallationInstall the library.python-mpipinstalldjango-tailwind-cliAdddjango_tailwind_clitoINSTALLED_APPSinsettings.py.INSTALLED_APPS=[# other Django apps"django_tailwind_cli",]Configure theSTATICFILES_DIRSparameter in yoursettings.pyif not already configured.STATICFILES_DIRS=[BASE_DIR/"assets"]Add template code.{%loadtailwind_cli%}...<head>...{%tailwind_css%}...</head>Start the debug server.pythonmanage.pytailwindrunserverEnjoy!Checkout the detailedinstallation guideif you want to activate browser reload or therunserver_plusmanagement command known fromdjango-extensions.FeaturesSimplest possible integration.Management commands:To start the Tailwind CLI in watch mode during development.To build the production grade CSS file for your project.To start a debug server along with the Tailwind CLI in watch mode in a single session.Necessary configuration to adapt the library to your project, when the defaults don't fit you.A template tag to include the Tailwind CSS file in your project.A base template for your project.A sane tailwind.config.js that activates all the official plugins and includes a simple HTMX plugin.RequirementsPython 3.8 or newer with Django >= 3.2.DocumentationThe documentation can be found athttps://django-tailwind-cli.andrich.me/ContributingIf you want to contribute to this project, checkout thedevelopment guidefor details to get your dev environment up and running.LicenseThis software is licensed underMIT license.
Package: django-tailwindcss
English |中文django-tailwindcssDevelop with Tailwind CSS in Django flavour.Quick Start1. Install django-tailwindcss from pippip install django-tailwindcss2. Download Tailwind CSS CLI file and create tailwind.config.jsCLI file can be download fromhttps://github.com/tailwindlabs/tailwindcss/releasestailwind.config.jscan be found athttps://tailwindcss.com/docs/installationExample:module.exports = {
  content: ["./**/*.{html,js}"],
  theme: {
    extend: {},
  },
  plugins: [],
}Storetailwindcss-linux-x64(for linux) andtailwind.config.jsat the same directory ofmanage.py.And your projectprojshould be like:proj
├── proj
│   └── settings.py
├── manage.py
├── tailwindcss-linux-x64
└── tailwind.config.js3. Add tailwindcss to your settings.INSTALLED_APPSINSTALLED_APPS=[..."tailwindcss",...]4. Create these variables in your settings# BASE_DIR = Path(__file__).resolve().parentTAILWINDCSS_CLI_FILE=BASE_DIR/'tailwindcss-linux-x64'TAILWINDCSS_CONFIG_FILE=BASE_DIR/'tailwind.config.js'# For file modeTAILWINDCSS_OUTPUT_FILE='style.css'5. Use tailwindcss tag in your base template{% load tailwindcss %}<html><head>...
    {% tailwindcss %}
    ...</head>...</html>6. (Optional) Generate tailwindcss fileUsemaketailwindcsscommand to generate tailwindcss file inPath(settings.STATIC_ROOT) / settings.TAILWINDCSS_OUTPUT_FILE.python manage.py maketailwindcss{% tailwindcss %}output will be changed to use exist file.Cachedjango-tailwindcssCSS generation step is deferred until the first visit to a page that uses thetailwindcsstag. The generated CSS is stored in the cache to speed up page loading and prevent blocking the Django process, and for modified and reloaded CSS there is still a waiting period before it takes effect automatically.This works well with the defaultLocMemCachecaching backend, but when using theDummyCachebackend it degrades to a pre-0.3.0 state, as this backend has no cache at all.Note that when using theMemcached,Redis,DatabaseCache,FileBasedCachecaching backends, the cache is not automatically cleared as theLocMemCachebackend is when the process is restarted, so this may result in out-of-date CSS being used after updating a file, for which therefreshtailwindcssmanagement command has been added to facilitate manual refreshing of the cache.python manage.py refreshtailwindcssInternaldjango-tailwindcssgenerates CSS each time django startupandfile changes.And{% tailwindcss %}outputs are same as:<style>/*! tailwindcss v3.0.23 | MIT License | https://tailwindcss.com*/*,:after,:before{border:0solid#e5e7eb;box-sizing:border-box}...</style>So you usually only need to add it once.If you addrawargument like{% tailwindcss raw=True %}, the output are same as:/*! tailwindcss v3.0.23 | MIT License | https://tailwindcss.com*/*,:after,:before{border:0 solid #e5e7eb;box-sizing:border-box}...If you generated tailwindcss file, the output are same as:<linkrel="stylesheet"type="text/css"href="...">
Package: django-talar
django-talarDjango app forTalarservice.Installationpip install django-talar.Adddjango_talarto your django settingsINSTALLED_APPS.Modify code below and also insert it into django settings:TALAR={'project_id':env.str('TALAR_PROJECT_ID',None),'key_id':env.str('TALAR_KEY_ID',None),'key_secret':env.str('TALAR_KEY_SECRET',None),}Include this into your core urls:path('talar/',include(('django_talar.urls','talar'))),Basic usagedjango-talar contains basic formdjango_talar.forms.PaymentFormand templatedjango_talar/talar_make_payment.htmlfor making payments. It is suggested to
use it by adding your own view like so:defmake_payment(request):data={'external_id':EXTERNAL_ID,# You order/payment unique key that will be used to identify payment'amount':AMOUNT,# your data'currency':CURRENCY,# your data'continue_url':CONTINUE_URL,# Insert address for redirection after successfull payment}talar=Talar(settings.TALAR['project_id'],settings.TALAR['key_id'],settings.TALAR['key_secret'])url=talar.urldata=talar.create_payment_data(data)payment_form=PaymentForm(data={'key_id':talar.access_key_id,'encrypted':data})returnrender(request,'django_talar/make_payment.html',{'url':url,'payment_form':payment_form})html code will handle redirection if everything is correct:<div><p>{% trans 'After continuing you will be redirected to payment provider site.' %}</p><formaction="{{ url }}"method="post"class="form-inline">{{ payment_form.as_p }}<buttontype=submitclass="btn btn-primary">{% trans 'Pay' %}</button></form></div>
Package: djangotalkto
Django TalkToOverviewDjango TalkTo allows you to consume RESTful APIs seamlessly without need to create databaseModelTalkToModel, inherits the django Model class, but won't create any migration files, :smiley:APIManager, inherits Django Manager(I won't touch your DB i promise :yum: )ModelFormTalkToModelForm, inherits Django ModelForm.ViewsTalkToWriteViewwhich makesPOST/PUTrequest to an endpoint (Django CreateView and UpdateView in one pot :wink: )TalkToListViewwhich makesGETrequest to an endpoint (Django ListView, no bigs)TalkToDetailViewwhich makesGETrequest with a parameter (Django DetailView)Django Rest FrameworksupportYou can also use Django TalkTo withDjango Rest FrameworkSerializerTalkToModelSerializer, inherits DRF ModelSerializer, that won't touch the DB, cool right?ViewTalkToAPIViewwhich makesPOST,GETandPUTrequests.DELETErequests coming soon.InstallationInstall using pippip install djangotalktoNotes toDjango Rest FrameworkusersYou need to have djangorestframework installed and added toINSTALLED_APPSin settings. You can install it with djangotalkto usingpip install djangotalkto[rest]UsageStart a new django projectpip install django
django-admin startproject newproj .
pip install djangotalktoAdd'talkto'toINSTALLED_APPSin your project settingsThen create TALKTO dict in your settings with the following propertiesTALKTO = {
    'default': {
        'URL': 'your-api-base-url', #Important!
        'HEADERS': {key: value}, # You can add your Authorization here
    }

}Creating your Modelfrom talkto.models import TalkToModel, APIManager
from django.db import models
class SampleModel(TalkToModel):
    name = models.CharField(max_length=255)
    age = models.IntegerField()

    # Then add your APIManager with the variable name 'api'

    api = APIManager(path='user/')

    # 'path' in this case is the path you will be making your request which is 
    # concatenated with the URL set in TALKTO config in settings.pyCreating your ModelForm is much like the same.from talkto.forms import TalkToModelForm


class SampleForm(TalkToModelForm):
    class Meta:
        model = SampleModel
        fields = '__all__'Viewsfrom talkto.views import TalkToWriteView, TalkToDetailView, TalkToListView

class TestCreate(TalkToWriteView):
    form_class = SampleForm
    model = SampleModel
    success_url = reverse_lazy('books')
    template_name = 'index.html'

# Detail view

class SampleDetail(TalkToDetailView):
    model = SampleModel
    template_name = 'detail.html'


# List view

class SampleList(TalkToListView):
    model = SampleModel
    template_name = 'detail.html'URLConf works the same.Django Rest FrameworkSerializerfrom talkto.serializer import TalkToModelSerializer

class SampleSerializer(TalkToModelSerializer):
    class Meta:
        model = SampleModel
        fields = '__all__'API Viewclass SampleView(TalkToAPIView):
    model = SampleModel
    serializer_class = SampleSerializerURLConf works the same.CONTRIBUTINGcoming soon....SupportsAs this is still in it's early project there might be some use cases that are not covered.
Therefore you can contact me using the following channels.Follow me onTwitterFollow me onReddit
Package: django-tango
Faster, simpler django content management.##Installation:###Install via pip:pip install django-tangoOr, if you want the very latest version from GitHub:pip install git+https://github.com/tBaxter/Tango.gitIf you’re installing in a fresh, brand-new virtualenvironment – and you are using a virtualenvironment, right? – then you’ll see a lot of stuff fly by.
Don’t worry, that’s just the dependencies.
If your environment already has the usual stuff installed (Django, PIL, etc),
then you’ll speed through the Tango install.For more info, see the “Dependencies” section.###For a new project, run the [Tango Starter Kit](https://github.com/tBaxter/tango-starter-kit):django-admin.py startproject –template=https://github.com/tBaxter/tango-starter-kit/archive/master.zip test_projectNote: test_project should (of course) be changed to the name of your project### What then?
If you used the starter project, a basic test database was included.
Just run manage.py runserver and you’ll have a working site.
You can log into the admin with username:admin, password:test.
Obviously, you’ll want to change that right away.If not, you’ll want to run syncdb or South.Then start adding content. That’s it.### Before you go live
Before the site is ready to go live, you’ll want to change some settings and hook up a real database, of course.
Before users can register and sign in, you’ll also need to configure user registration and authentication. We like [django-allauth](https://github.com/pennersr/django-allauth), but have also used and liked django-registration.## So what batteries are included?
* [News/articles/blogs](https://github.com/tBaxter/tango-articles)
* [Photo galleries](https://github.com/tBaxter/tango-photos)
* Sophisticated contact and user submissions forms courtesy of [Tango Contact Manager](https://github.com/tBaxter/tango-contact-manager)
* Video integration with Youtube, Hulu and uStream
* Robust event calendars and management with [Tango Happenings](https://github.com/tBaxter/tango-happenings)
* A straighforward user profile model (that you’re welcome to ignore if you have your own)
* An updated, responsive admin theme.
* Capo, a simple SASS-based framework for quickly styling your site.### What else?
* Clear, easy-to-understand code.
* Plug and play. Whether you want a new site in minutes or just want an app, you’re covered.
* Full multi-site support.
* Tango doesn’t take over your project. It works with your other code.
* Don’t want all of it? You can get just the pieces you want, and throw out the pieces you don’t want.##Dependencies (these should be installed for you)
[Django 1.5.1 +](https://www.djangoproject.com)
PIL or Pillow (Your choice)
[Easy-Thumbnails](https://github.com/SmileyChris/easy-thumbnails)
Markdown & Typogrify for nice text formatting
django-filter
vobject
[Python-Twitter](https://github.com/bear/python-twitter) (if you want to auto-tweet news items)### Recommended
docutils
Package: django-taobao
a django plugin forTaobao Open APIinstallpip install django-taobaoconfigurecurrently it’s highly depand onpython social authfor OAuth2
authentication. so the only thing you need to do for authentication is
open your djangosettings.pyand add these variable:INSTALLED_APPS = (
    ...
    'django_taobao',
    'django_social_auth.apps.django_app.default',
)

AUTHENTICATION_BACKENDS = [
    'social.backends.taobao.TAOBAOAuth',
]

SOCIAL_AUTH_TAOBAO_KEY = 'your client id'
SOCIAL_AUTH_TAOBAO_SECRET = 'your app secret'
      TAOBAO_API_URL ='https://gw.api.tbsandbox.com/router/rest'now modify yoururls.py:url(r'^taobao/', include('taobao.urls')), # this is taobao api example
url('', include('social.apps.django_app.urls', namespace='social')), # this is for authnow you can just visityouhost.com/login/taobaologin and get thetokenhow to use the APInow with the token just got, you can use taobao api now.
the get user info example inview.pyshow how to use the api:def user_info(request):
          print request.user.id
          user = get_object_or_404(UserSocialAuth.objects.filter(provider='taobao'),user=request.user)
          token = user.extra_data['access_token']
          t = TaoBao()
          t.setParams(access_token=token, method='taobao.user.seller.get')
          t.setFields('nick,sex')
          return render_to_response("taobao/index.html", RequestContext(request, {'seller':t.fetch()}))ContributeIssue Tracker:https://github.com/jcouyang/django-taobao/issuesSource Code:https://github.com/jcouyang/django-taobao
Package: django-tapatalk
A DjangoBB Tapatalk API implementationDjango Tapatalk tries to implement all the v3 api calls for tapatalk. The default methods are for djangobb, but are easily extended to your own methods (see ‘Customization’ section, for the TAPATALK_METHODS mapping).RequirementsDjangobb-forum <http://djangobb.org/>Django-xmlrpc <http://pypi.python.org/pypi/django-xmlrpc>It’s recommended that you also use django-messages (<http://code.google.com/p/django-messages/>), if you want to use PM’s out of the box (or provide your own implementation, see the ‘settings’ section).InstallationThe easiest way is via pip:pip install django-tapatalkOr you could retrieve the source from github or pypy, and install it via the setup.py.UsageRegistertapatalkin your INSTALLED_APPS section of your project’ settings, and add these urls to your installation:(r'^tapatalk/', include('tapatalk.urls')),
(r'^forum/mobiquo/', include('tapatalk.urls')),The 2nd line is optional, but that is the default directory Tapatalk will look for, so I recommend you add it.CustomizationIf you want to customize some methods, for instance, your login procedure, you define your own methods. Every method gets the request variable as first argument, and it’s recommended that you use the standard request.user for referencing the current logged in user.You can register extra methods or custom methods via the TAPATALK_METHODS variable:TAPATALK_METHODS = (
  ('my.awesome.login', 'login'),
  ('myapp.get_config', 'get_config'),
  ('myapp.get_forum', 'get_forum'),
  ('myapp.search_topic', 'search_topic'),
  ('myapp.get_online_users', 'get_online_users'),
  ('moar.awesomeness.ponies', 'ponies'),
  # etc.
)FeaturesLogin via standard Django/djangobb loginParticipated topicsList all topicsRead topicCreate topicReply to topicEdit postForum listingsStickie listingsAnnouncementsSubscriptions (Post)Search (Post/Topic)Private Messages, inbox/sentSend, replying and reading of Private MessagesOnline usersUser profilesUser posts, user topicsMissing:Mark all as readPagination(!)Subscriptions (Forum) (djangobb doesn’t support forum subscriptions afaik)The user avatars are not implemented correctlyMoar testsHelp!Please help out by sending a pull request, or send me a github messageAcknowledgementI wish no one has to endure implementing the Tapatalk api as I did, the documentation is bad. The Tapatalk app makes weird assumptions and will fall back to undocumented features whenever you do something wrong, without letting you know why, or how to fix the problem. This implementation is based upon reverse engineering of the protocol over Charles and looking at the php source code for some of the plugins…So, I know I will never get those countless hours back to my life, but let’s hope I can save some of yours. If you have any questions, please let me know, as I will be glad to help. Also, be sure to checkout the tapatalk forums, as there are some nice and smart people there :)
Package: django-tapeforms
UsagePlease refer to theDocumentationto
learn how to usedjango-tapeforms. Basicly,tapeformsprovides a mixin
and some Django template tags to help you render your forms to HTML.Requirementsdjango-tapeforms supports Python 3 only and requires at least Django 2.2.
No other dependencies are required.Prepare for developmentA Python 3.6 interpreter is required in addition to pipenv.$poetryinstallNow you’re ready to start the example project to experiment with tapeforms.$poetryrunpythonexamples/manage.pyrunserver
Package: django-tarantool
Django Tarantool database backendInstallationInstall Tarantool v2.2+. See the installation manual for your OShereMake a database directory and run Tarantool instance there:$mkdir~/project_db
$cd~/project_db
$tarantoolYou will see the Tarantool interpreter. Initialize DB configuration and create password foradmintarantool> box.cfg({ listen = 3301 })
tarantool> box.schema.user.passwd('admin', 'password')To get started with django-tarantool, run the following in a virtual environment:pipinstalldjango-tarantoolAddDATABASESconfig of your Tarantool intosettings.pyDATABASES={'default':{'ENGINE':'django_tarantool.backend','HOST':'127.0.0.1','PORT':'3301','USER':'admin','PASSWORD':'password','CONN_MAX_AGE':3600,}}Mind usingCONN_MAX_AGEparam as very important. It allows to keep connection opened for the specified time in
seconds. Otherwise, Django will open the connection to the Tarantool instance on each request and close after it, which
increases the request latency.Runmigrateas usual:pythonmanage.pymigrateRun Django development server:pythonmanage.pyrunserver0:8000
Package: django-tarview
Django TarView==============A base view to tar and stream several files.Installation------------pip install django-tarviewUsage and examples------------------To create a tar download view:* Extend BaseTarView* implement `get_files`* That's itThe `get_files` method must return a list (or iterator) of file-like objects.Example with a ContentFile:```from tarview.views import BaseTarViewclass JustTextFilesView(BaseTarView):"""Generate a tar with 10 files 'fileX.txt' with a simple text,using Djangos ContentFile"""def get_files(self):for i in range(0,10):file_like = ContentFile(b("This is file %d." % i), name="file%d.txt" % i)yield file_like```Or pull them from a database like this:```pythonfrom tarview.views import BaseTarViewfrom reviews import Reviewclass CommentsArchiveView(BaseTarView):"""Download at once all comments for a review."""def get_files(self):document_key = self.kwargs.get('document_key')reviews = Review.objects \.filter(document__document_key=document_key) \.exclude(comments__isnull=True)return [review.comments.file for review in reviews if review.comments.name]```View configuration------------------By default, the downloaded file is named `download.tar` you can set a custom nameby setting the `tarfile_name` parameter.```pythonclass TarView(BaseTarView):tarfile_name = 'something.tar'```Testing-------Django TarView uses [tox, the testing automation tool](https://tox.readthedocs.org/en/latest/),to run tests.To launch tests:pip install toxtoxAuthor------Crafted with love by luckydonald.Modification of [Thibault Jouannic](http://www.miximum.fr)'s work.
Package: django-tasix
# django-tasix[![BuildStatus](https://travis-ci.org/muminoff/django-tasix.svg?branch=master)](https://travis-ci.org/muminoff/django-tasix)## What is Tas-IX?Data exchange network in Uzbekistan, where many domestic ISP providers give access to resources within the network to their subscribers for free.## What is `django-tasix`?Simple django app to detect ip adresses/ranges of coming HTTP requests in middleware layer.# Requirements* Python (3.2, 3.3, 3.4, 3.5)* Django (1.10)# InstallationInstall using `pip`:pip install django-tasixThere are 2 ways for using this app:1. Middleware style (blocks every request outside Tas-IX)2. Decorator style (blocks certain requests outside Tas-IX)### Middleware styleAdd `'tasix'` to your `MIDDLEWARE_CLASSES` setting:MIDDLEWARE_CLASSES = (# other middleware classes'tasix.middleware.TasixMiddleware',)### Decorator styleImport `allow_tasix` decorator in your viewfrom django.http import HttpResponsefrom tasix.decorators import allow_tasix@allow_tasixdef index_view(request):return HttpResponse('Only Tas-IX users can view this')## DisclaimerNetwork range is being fetched manually from `http://tasix.sarkor.uz/full`, meaning correctness is based on 3rd party ISP provider which releases network information periodically.## LicenseBSD
Package: django-taskboard
Quick startInclude the URLconf in your project urls.py:path('taskboard/', include('taskboard.urls')),Include the app in your project settings.py:INSTALLED_APPS = [
    'taskboard.apps.Taskboard',
]Configure the session engine in your project settings.py:SESSION_ENGINE = 'django.contrib.sessions.backends.file',Configure the admins object in your project settings.py:TASKBOARD_ADMINS = [
    {'username': 'admin', 'password': 'admin', 'name': 'Administrator'},
]Visithttp://127.0.0.1:8000/taskboard/to open the dashboard.Buildpython setup.py sdisttwine upload dist/*
Package: django-taskd
django-taskd: A taskd implementation for the Django web frameworkRequirementsDjangoA workingredshirtinstanceInstallation(soon):pip install django-taskdAddtaskdjto your INSTALLED_APPS in settings.pyFrom source:git clone https://github.com/asabine/django-taskd.gitpython setup.py installAddtaskdjto your INSTALLED_APPS in settings.py