2 |
16 |
--------------------------------------------------------------------------------
/django_common/templatetags/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Tivix/django-common/407d208121011a8425139e541629554114d96c18/django_common/templatetags/__init__.py
--------------------------------------------------------------------------------
/django_common/templatetags/custom_tags.py:
--------------------------------------------------------------------------------
1 | from __future__ import print_function, unicode_literals, with_statement, division
2 |
3 | from django import template
4 | from django.forms import widgets
5 | from django.template.loader import get_template
6 |
7 | register = template.Library()
8 |
9 |
10 | class FormFieldNode(template.Node):
11 | """
12 | Helper class for the render_form_field below
13 | """
14 | def __init__(self, form_field, help_text=None, css_classes=None):
15 | self.form_field = template.Variable(form_field)
16 | self.help_text = help_text[1:-1] if help_text else help_text
17 | self.css_classes = css_classes[1:-1] if css_classes else css_classes
18 |
19 | def render(self, context):
20 |
21 | try:
22 | form_field = self.form_field.resolve(context)
23 | except template.VariableDoesNotExist:
24 | return ''
25 |
26 | widget = form_field.field.widget
27 |
28 | if isinstance(widget, widgets.HiddenInput):
29 | return form_field
30 | elif isinstance(widget, widgets.RadioSelect):
31 | t = get_template('common/fragments/radio_field.html')
32 | elif isinstance(widget, widgets.CheckboxInput):
33 | t = get_template('common/fragments/checkbox_field.html')
34 | elif isinstance(widget, widgets.CheckboxSelectMultiple):
35 | t = get_template('common/fragments/multi_checkbox_field.html')
36 | else:
37 | t = get_template('common/fragments/form_field.html')
38 |
39 | help_text = self.help_text
40 | if help_text is None:
41 | help_text = form_field.help_text
42 |
43 | return t.render({
44 | 'form_field': form_field,
45 | 'help_text': help_text,
46 | 'css_classes': self.css_classes
47 | })
48 |
49 |
50 | @register.tag
51 | def render_form_field(parser, token):
52 | """
53 | Usage is {% render_form_field form.field_name optional_help_text optional_css_classes %}
54 |
55 | - optional_help_text and optional_css_classes are strings
56 | - if optional_help_text is not given, then it is taken from form field object
57 | """
58 | try:
59 | help_text = None
60 | css_classes = None
61 |
62 | token_split = token.split_contents()
63 | if len(token_split) == 4:
64 | tag_name, form_field, help_text, css_classes = token.split_contents()
65 | elif len(token_split) == 3:
66 | tag_name, form_field, help_text = token.split_contents()
67 | else:
68 | tag_name, form_field = token.split_contents()
69 | except ValueError:
70 | raise template.TemplateSyntaxError(
71 | "Unable to parse arguments for {0}".format(repr(token.contents.split()[0])))
72 |
73 | return FormFieldNode(form_field, help_text=help_text, css_classes=css_classes)
74 |
75 |
76 | @register.simple_tag
77 | def active(request, pattern):
78 | """
79 | Returns the string 'active' if pattern matches.
80 | Used to assign a css class in navigation bars to active tab/section.
81 | """
82 | if request.path == pattern:
83 | return 'active'
84 | return ''
85 |
86 |
87 | @register.simple_tag
88 | def active_starts(request, pattern):
89 | """
90 | Returns the string 'active' if request url starts with pattern.
91 | Used to assign a css class in navigation bars to active tab/section.
92 | """
93 | if request.path.startswith(pattern):
94 | return 'active'
95 | return ''
96 |
--------------------------------------------------------------------------------
/django_common/tests.py:
--------------------------------------------------------------------------------
1 | from __future__ import print_function, unicode_literals, with_statement, division
2 |
3 | from django.utils import unittest
4 | from django.core.management import call_command
5 |
6 | try:
7 | from cStringIO import StringIO
8 | except ImportError:
9 | from StringIO import StringIO
10 |
11 | import sys
12 | import random
13 |
14 |
15 | class SimpleTestCase(unittest.TestCase):
16 | def setUp(self):
17 | pass
18 |
19 | def test_generate_secret_key(self):
20 | """ Test generation of a secret key """
21 | out = StringIO()
22 | sys.stdout = out
23 |
24 | for i in range(10):
25 | random_number = random.randrange(10, 100)
26 | call_command('generate_secret_key', length=random_number)
27 | secret_key = self._get_secret_key(out.getvalue())
28 |
29 | out.truncate(0)
30 | out.seek(0)
31 |
32 | assert len(secret_key) == random_number
33 |
34 | def _get_secret_key(self, result):
35 | """ Get only the value of a SECRET_KEY """
36 | for index, key in enumerate(result):
37 | if key == ':':
38 | return str(result[index + 1:]).strip()
39 |
--------------------------------------------------------------------------------
/django_common/tzinfo.py:
--------------------------------------------------------------------------------
1 | from __future__ import print_function, unicode_literals, with_statement, division
2 |
3 | # From the python documentation
4 | # http://docs.python.org/library/datetime.html
5 | from datetime import tzinfo, timedelta, datetime
6 |
7 | ZERO = timedelta(0)
8 | HOUR = timedelta(hours=1)
9 |
10 | # A UTC class.
11 |
12 |
13 | class UTC(tzinfo):
14 | """
15 | UTC
16 | """
17 | def utcoffset(self, dt):
18 | return ZERO
19 |
20 | def tzname(self, dt):
21 | return "UTC"
22 |
23 | def dst(self, dt):
24 | return ZERO
25 |
26 | utc = UTC()
27 |
28 | # A class building tzinfo objects for fixed-offset time zones.
29 | # Note that FixedOffset(0, "UTC") is a different way to build a
30 | # UTC tzinfo object.
31 |
32 |
33 | class FixedOffset(tzinfo):
34 | """
35 | Fixed offset in minutes east from UTC.
36 | """
37 | def __init__(self, offset, name):
38 | self.__offset = timedelta(minutes=offset)
39 | self.__name = name
40 |
41 | def utcoffset(self, dt):
42 | return self.__offset
43 |
44 | def tzname(self, dt):
45 | return self.__name
46 |
47 | def dst(self, dt):
48 | return ZERO
49 |
50 | # A class capturing the platform's idea of local time.
51 |
52 | import time as _time
53 |
54 | STDOFFSET = timedelta(seconds=-_time.timezone)
55 | if _time.daylight:
56 | DSTOFFSET = timedelta(seconds=-_time.altzone)
57 | else:
58 | DSTOFFSET = STDOFFSET
59 |
60 | DSTDIFF = DSTOFFSET - STDOFFSET
61 |
62 |
63 | class LocalTimezone(tzinfo):
64 | def utcoffset(self, dt):
65 | if self._isdst(dt):
66 | return DSTOFFSET
67 | else:
68 | return STDOFFSET
69 |
70 | def dst(self, dt):
71 | if self._isdst(dt):
72 | return DSTDIFF
73 | else:
74 | return ZERO
75 |
76 | def tzname(self, dt):
77 | return _time.tzname[self._isdst(dt)]
78 |
79 | def _isdst(self, dt):
80 | tt = (dt.year, dt.month, dt.day,
81 | dt.hour, dt.minute, dt.second,
82 | dt.weekday(), 0, -1)
83 | stamp = _time.mktime(tt)
84 | tt = _time.localtime(stamp)
85 | return tt.tm_isdst > 0
86 |
87 | Local = LocalTimezone()
88 |
89 |
90 | # A complete implementation of current DST rules for major US time zones.
91 |
92 | def first_sunday_on_or_after(dt):
93 | days_to_go = 6 - dt.weekday()
94 | if days_to_go:
95 | dt += timedelta(days_to_go)
96 | return dt
97 |
98 |
99 | # US DST Rules
100 | #
101 | # This is a simplified (i.e., wrong for a few cases) set of rules for US
102 | # DST start and end times. For a complete and up-to-date set of DST rules
103 | # and timezone definitions, visit the Olson Database (or try pytz):
104 | # http://www.twinsun.com/tz/tz-link.htm
105 | # http://sourceforge.net/projects/pytz/ (might not be up-to-date)
106 | #
107 | # In the US, since 2007, DST starts at 2am (standard time) on the second
108 | # Sunday in March, which is the first Sunday on or after Mar 8.
109 | DSTSTART_2007 = datetime(1, 3, 8, 2)
110 | # and ends at 2am (DST time; 1am standard time) on the first Sunday of Nov.
111 | DSTEND_2007 = datetime(1, 11, 1, 1)
112 | # From 1987 to 2006, DST used to start at 2am (standard time) on the first
113 | # Sunday in April and to end at 2am (DST time; 1am standard time) on the last
114 | # Sunday of October, which is the first Sunday on or after Oct 25.
115 | DSTSTART_1987_2006 = datetime(1, 4, 1, 2)
116 | DSTEND_1987_2006 = datetime(1, 10, 25, 1)
117 | # From 1967 to 1986, DST used to start at 2am (standard time) on the last
118 | # Sunday in April (the one on or after April 24) and to end at 2am (DST time;
119 | # 1am standard time) on the last Sunday of October, which is the first Sunday
120 | # on or after Oct 25.
121 | DSTSTART_1967_1986 = datetime(1, 4, 24, 2)
122 | DSTEND_1967_1986 = DSTEND_1987_2006
123 |
124 |
125 | class USTimeZone(tzinfo):
126 | def __init__(self, hours, reprname, stdname, dstname):
127 | self.stdoffset = timedelta(hours=hours)
128 | self.reprname = reprname
129 | self.stdname = stdname
130 | self.dstname = dstname
131 |
132 | def __repr__(self):
133 | return self.reprname
134 |
135 | def tzname(self, dt):
136 | if self.dst(dt):
137 | return self.dstname
138 | else:
139 | return self.stdname
140 |
141 | def utcoffset(self, dt):
142 | return self.stdoffset + self.dst(dt)
143 |
144 | def dst(self, dt):
145 | if dt is None or dt.tzinfo is None:
146 | # An exception may be sensible here, in one or both cases.
147 | # It depends on how you want to treat them. The default
148 | # fromutc() implementation (called by the default astimezone()
149 | # implementation) passes a datetime with dt.tzinfo is self.
150 | return ZERO
151 | assert dt.tzinfo is self
152 |
153 | # Find start and end times for US DST. For years before 1967, return
154 | # ZERO for no DST.
155 | if 2006 < dt.year:
156 | dststart, dstend = DSTSTART_2007, DSTEND_2007
157 | elif 1986 < dt.year < 2007:
158 | dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
159 | elif 1966 < dt.year < 1987:
160 | dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
161 | else:
162 | return ZERO
163 |
164 | start = first_sunday_on_or_after(dststart.replace(year=dt.year))
165 | end = first_sunday_on_or_after(dstend.replace(year=dt.year))
166 |
167 | # Can't compare naive to aware objects, so strip the timezone from
168 | # dt first.
169 | if start <= dt.replace(tzinfo=None) < end:
170 | return HOUR
171 | else:
172 | return ZERO
173 |
174 | Eastern = USTimeZone(-5, "Eastern", "EST", "EDT")
175 | Central = USTimeZone(-6, "Central", "CST", "CDT")
176 | Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
177 | Pacific = USTimeZone(-8, "Pacific", "PST", "PDT")
178 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | try:
4 | from setuptools import setup, find_packages
5 | except ImportError:
6 | from ez_setup import use_setuptools
7 | use_setuptools()
8 | from setuptools import setup, find_packages
9 |
10 | from django_common import settings
11 |
12 | import os
13 |
14 | here = os.path.dirname(os.path.abspath(__file__))
15 | f = open(os.path.join(here, 'README.rst'))
16 | long_description = f.read().strip()
17 | f.close()
18 |
19 | setup(
20 | name='django-common-helpers',
21 | version=settings.VERSION,
22 | author='Tivix',
23 | author_email='dev@tivix.com',
24 | url='http://github.com/tivix/django-common',
25 | description='Common things every Django app needs!',
26 | packages=find_packages(),
27 | long_description=long_description,
28 | keywords='django',
29 | zip_safe=False,
30 | install_requires=[
31 | 'Django>=1.8.0'
32 | ],
33 | test_suite='django_common.tests',
34 | include_package_data=True,
35 | classifiers=[
36 | 'Framework :: Django',
37 | 'Intended Audience :: Developers',
38 | 'Intended Audience :: System Administrators',
39 | 'Operating System :: OS Independent',
40 | 'Topic :: Software Development'
41 | ],
42 | )
43 |
--------------------------------------------------------------------------------