How to not import django here?
Question: I have filter that I took from django but now I must import too much of django
which I don't want and I must put the strange line in my file:

`os.environ['DJANGO_SETTINGS_MODULE'] = 'locale'`

This shouldn't be needed since I'm not using django. I use Jinja2 and I took
the floatformat filter from django and using it with jinja2 which works if I
do the crazy imports:

    
    
    os.environ['DJANGO_SETTINGS_MODULE'] = 'locale'
    from django.utils.encoding import force_unicode, iri_to_uri
    from django.utils.safestring import mark_safe, SafeData, mark_for_escaping
    from django.utils import formats
    # Values for testing floatformat input against infinity and NaN representations,
    # which differ across platforms and Python versions.  Some (i.e. old Windows
    # ones) are not recognized by Decimal but we want to return them unchanged vs.
    # returning an empty string as we do for completley invalid input.  Note these
    # need to be built up from values that are not inf/nan, since inf/nan values do
    # not reload properly from .pyc files on Windows prior to some level of Python 2.5
    # (see Python Issue757815 and Issue1080440).
    pos_inf = 1e200 * 1e200
    neg_inf = -1e200 * 1e200
    nan = (1e200 * 1e200) // (1e200 * 1e200)
    special_floats = [str(pos_inf), str(neg_inf), str(nan)]
    
    def floatformat(text, arg=-1):
        """
        Displays a float to a specified number of decimal places.
    
        If called without an argument, it displays the floating point number with
        one decimal place -- but only if there's a decimal place to be displayed:
    
        * num1 = 34.23234
        * num2 = 34.00000
        * num3 = 34.26000
        * {{ num1|floatformat }} displays "34.2"
        * {{ num2|floatformat }} displays "34"
        * {{ num3|floatformat }} displays "34.3"
    
        If arg is positive, it will always display exactly arg number of decimal
        places:
    
        * {{ num1|floatformat:3 }} displays "34.232"
        * {{ num2|floatformat:3 }} displays "34.000"
        * {{ num3|floatformat:3 }} displays "34.260"
    
        If arg is negative, it will display arg number of decimal places -- but
        only if there are places to be displayed:
    
        * {{ num1|floatformat:"-3" }} displays "34.232"
        * {{ num2|floatformat:"-3" }} displays "34"
        * {{ num3|floatformat:"-3" }} displays "34.260"
    
        If the input float is infinity or NaN, the (platform-dependent) string
        representation of that value will be displayed.
        """
    
        try:
            input_val = force_unicode(text)
            d = Decimal(input_val)
        except UnicodeEncodeError:
            return u''
        except InvalidOperation:
            if input_val in special_floats:
                return input_val
            try:
                d = Decimal(force_unicode(float(text)))
            except (ValueError, InvalidOperation, TypeError, UnicodeEncodeError):
                return u''
        try:
            p = int(arg)
        except ValueError:
            return input_val
    
        try:
            m = int(d) - d
        except (ValueError, OverflowError, InvalidOperation):
            return input_val
    
        if not m and p < 0:
            return formats.number_format(u'%d' % (int(d)), 0)
    
        if p == 0:
            exp = Decimal(1)
        else:
            exp = Decimal(u'1.0') / (Decimal(10) ** abs(p))
        try:
            # Avoid conversion to scientific notation by accessing `sign`, `digits`
            # and `exponent` from `Decimal.as_tuple()` directly.
            sign, digits, exponent = d.quantize(exp, ROUND_HALF_UP).as_tuple()
            digits = [unicode(digit) for digit in reversed(digits)]
            while len(digits) <= abs(exponent):
                digits.append(u'0')
            digits.insert(-exponent, u'.')
            if sign:
                digits.append(u'-')
            number = u''.join(reversed(digits))
            return formats.number_format(number, abs(p))
        except InvalidOperation:
            return input_val
    

Can I achieve this filter's function without the django imports and with no
fake django setting that I just put there just because it asked for it?

Thank you for any help

## Update

I copied insane amounts of django code for this little use case and it s still
not working since I can't find the function `get_real_language`that I must
take from django:

    
    
    # -*- coding: utf-8 -*-
    from datetime import datetime
    from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
    import os
    def datetimeformat(value, format='%H:%M / %d-%m-%Y'):
        return value.strftime(format)
    
    def timesince(value, default="just now"):
        now = datetime.utcnow()
        diff = now - value
        periods = (
            (diff.days / 365, "year", "years"),
            (diff.days / 30, "month", "months"),
            (diff.days / 7, "week", "weeks"),
            (diff.days, "day", "days"),
            (diff.seconds / 3600, "hour", "hours"),
            (diff.seconds / 60, "minute", "minutes"),
            (diff.seconds, "second", "seconds"),
        )
        for period, singular, plural in periods:
            if period:
                return "%d %s ago" % (period, singular if period == 1 else plural)
        return default
    
    def makeid(n, countrycode="46"):
        countrycode = str(countrycode)
        n = str(n)
        return "%s%s%s" % (countrycode, '0'*(12-len(countrycode)-len(n)), n)
    
    # Values for testing floatformat input against infinity and NaN representations,
    # which differ across platforms and Python versions.  Some (i.e. old Windows
    # ones) are not recognized by Decimal but we want to return them unchanged vs.
    # returning an empty string as we do for completley invalid input.  Note these
    # need to be built up from values that are not inf/nan, since inf/nan values do
    # not reload properly from .pyc files on Windows prior to some level of Python 2.5
    # (see Python Issue757815 and Issue1080440).
    pos_inf = 1e200 * 1e200
    neg_inf = -1e200 * 1e200
    nan = (1e200 * 1e200) // (1e200 * 1e200)
    special_floats = [str(pos_inf), str(neg_inf), str(nan)]
    
    def floatformat(text, arg=-1):
        """
        Displays a float to a specified number of decimal places.
    
        If called without an argument, it displays the floating point number with
        one decimal place -- but only if there's a decimal place to be displayed:
    
        * num1 = 34.23234
        * num2 = 34.00000
        * num3 = 34.26000
        * {{ num1|floatformat }} displays "34.2"
        * {{ num2|floatformat }} displays "34"
        * {{ num3|floatformat }} displays "34.3"
    
        If arg is positive, it will always display exactly arg number of decimal
        places:
    
        * {{ num1|floatformat:3 }} displays "34.232"
        * {{ num2|floatformat:3 }} displays "34.000"
        * {{ num3|floatformat:3 }} displays "34.260"
    
        If arg is negative, it will display arg number of decimal places -- but
        only if there are places to be displayed:
    
        * {{ num1|floatformat:"-3" }} displays "34.232"
        * {{ num2|floatformat:"-3" }} displays "34"
        * {{ num3|floatformat:"-3" }} displays "34.260"
    
        If the input float is infinity or NaN, the (platform-dependent) string
        representation of that value will be displayed.
        """
    
        try:
            input_val = force_unicode(text)
            d = Decimal(input_val)
        except UnicodeEncodeError:
            return u''
        except InvalidOperation:
            if input_val in special_floats:
                return input_val
            try:
                d = Decimal(force_unicode(float(text)))
            except (ValueError, InvalidOperation, TypeError, UnicodeEncodeError):
                return u''
        try:
            p = int(arg)
        except ValueError:
            return input_val
    
        try:
            m = int(d) - d
        except (ValueError, OverflowError, InvalidOperation):
            return input_val
    
        if not m and p < 0:
            return number_format(u'%d' % (int(d)), 0)
    
        if p == 0:
            exp = Decimal(1)
        else:
            exp = Decimal(u'1.0') / (Decimal(10) ** abs(p))
        try:
            # Avoid conversion to scientific notation by accessing `sign`, `digits`
            # and `exponent` from `Decimal.as_tuple()` directly.
            sign, digits, exponent = d.quantize(exp, ROUND_HALF_UP).as_tuple()
            digits = [unicode(digit) for digit in reversed(digits)]
            while len(digits) <= abs(exponent):
                digits.append(u'0')
            digits.insert(-exponent, u'.')
            if sign:
                digits.append(u'-')
            number = u''.join(reversed(digits))
            return number_format(number, abs(p))
        except InvalidOperation:
            return input_val
    
    
    
    def force_unicode(s, encoding='utf-8', strings_only=False, errors='strict'):
        """
        Similar to smart_unicode, except that lazy instances are resolved to
        strings, rather than kept as lazy objects.
    
        If strings_only is True, don't convert (some) non-string-like objects.
        """
        if strings_only and is_protected_type(s):
            return s
        try:
            if not isinstance(s, basestring,):
                if hasattr(s, '__unicode__'):
                    s = unicode(s)
                else:
                    try:
                        s = unicode(str(s), encoding, errors)
                    except UnicodeEncodeError:
                        if not isinstance(s, Exception):
                            raise
                        # If we get to here, the caller has passed in an Exception
                        # subclass populated with non-ASCII data without special
                        # handling to display as a string. We need to handle this
                        # without raising a further exception. We do an
                        # approximation to what the Exception's standard str()
                        # output should be.
                        s = ' '.join([force_unicode(arg, encoding, strings_only,
                                errors) for arg in s])
            elif not isinstance(s, unicode):
                # Note: We use .decode() here, instead of unicode(s, encoding,
                # errors), so that if s is a SafeString, it ends up being a
                # SafeUnicode at the end.
                s = s.decode(encoding, errors)
        except UnicodeDecodeError, e:
            if not isinstance(s, Exception):
                raise DjangoUnicodeDecodeError(s, *e.args)
            else:
                # If we get to here, the caller has passed in an Exception
                # subclass populated with non-ASCII bytestring data without a
                # working unicode method. Try to handle this without raising a
                # further exception by individually forcing the exception args
                # to unicode.
                s = ' '.join([force_unicode(arg, encoding, strings_only,
                        errors) for arg in s])
        return s
    
    def pluralize(value, arg=u's'):
        """
        Returns a plural suffix if the value is not 1. By default, 's' is used as
        the suffix:
    
        * If value is 0, vote{{ value|pluralize }} displays "0 votes".
        * If value is 1, vote{{ value|pluralize }} displays "1 vote".
        * If value is 2, vote{{ value|pluralize }} displays "2 votes".
    
        If an argument is provided, that string is used instead:
    
        * If value is 0, class{{ value|pluralize:"es" }} displays "0 classes".
        * If value is 1, class{{ value|pluralize:"es" }} displays "1 class".
        * If value is 2, class{{ value|pluralize:"es" }} displays "2 classes".
    
        If the provided argument contains a comma, the text before the comma is
        used for the singular case and the text after the comma is used for the
        plural case:
    
        * If value is 0, cand{{ value|pluralize:"y,ies" }} displays "0 candies".
        * If value is 1, cand{{ value|pluralize:"y,ies" }} displays "1 candy".
        * If value is 2, cand{{ value|pluralize:"y,ies" }} displays "2 candies".
        """
        if not u',' in arg:
            arg = u',' + arg
        bits = arg.split(u',')
        if len(bits) > 2:
            return u''
        singular_suffix, plural_suffix = bits[:2]
    
        try:
            if int(value) != 1:
                return plural_suffix
        except ValueError: # Invalid string that's not a number.
            pass
        except TypeError: # Value isn't a string or a number; maybe it's a list?
            try:
                if len(value) != 1:
                    return plural_suffix
            except TypeError: # len() of unsized object.
                pass
        return singular_suffix
    pluralize.is_safe = False
    
    def number_format(value, decimal_pos=None):
        """
        Formats a numeric value using localization settings
        """
        return format(
            value,
            get_format('DECIMAL_SEPARATOR'),
            decimal_pos,
            get_format('NUMBER_GROUPING'),
            get_format('THOUSAND_SEPARATOR'),
        )
    
    def format(number, decimal_sep, decimal_pos, grouping=0, thousand_sep=''):
        """
        Gets a number (as a number or string), and returns it as a string,
        using formats definied as arguments:
    
        * decimal_sep: Decimal separator symbol (for example ".")
        * decimal_pos: Number of decimal positions
        * grouping: Number of digits in every group limited by thousand separator
        * thousand_sep: Thousand separator symbol (for example ",")
    
        """
        use_grouping = True#settings.USE_L10N and \
            #settings.USE_THOUSAND_SEPARATOR and grouping
        # Make the common case fast:
        if isinstance(number, int) and not use_grouping and not decimal_pos:
            return mark_safe(unicode(number))
        # sign
        if float(number) < 0:
            sign = '-'
        else:
            sign = ''
        str_number = unicode(number)
        if str_number[0] == '-':
            str_number = str_number[1:]
        # decimal part
        if '.' in str_number:
            int_part, dec_part = str_number.split('.')
            if decimal_pos:
                dec_part = dec_part[:decimal_pos]
        else:
            int_part, dec_part = str_number, ''
        if decimal_pos:
            dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
        if dec_part: dec_part = decimal_sep + dec_part
        # grouping
        if use_grouping:
            int_part_gd = ''
            for cnt, digit in enumerate(int_part[::-1]):
                if cnt and not cnt % grouping:
                    int_part_gd += thousand_sep
                int_part_gd += digit
            int_part = int_part_gd[::-1]
        return sign + int_part + dec_part
    
    def get_format(format_type):
        """
        For a specific format type, returns the format for the current
        language (locale), defaults to the format in the settings.
        format_type is the name of the format, e.g. 'DATE_FORMAT'
        """
        format_type = smart_str(format_type)
        if True:#settings.USE_L10N:
            cache_key = (format_type, get_language())
            try:
                return _format_cache[cache_key] or getattr(settings, format_type)
            except KeyError:
                for module in get_format_modules():
                    try:
                        val = getattr(module, format_type)
                        _format_cache[cache_key] = val
                        return val
                    except AttributeError:
                        pass
                _format_cache[cache_key] = None
        return getattr(settings, format_type)
    
    def smart_str(s, encoding='utf-8', strings_only=False, errors='strict'):
        """
        Returns a bytestring version of 's', encoded as specified in 'encoding'.
    
        If strings_only is True, don't convert (some) non-string-like objects.
        """
        if strings_only and isinstance(s, (types.NoneType, int)):
            return s
        if isinstance(s, Promise):
            return unicode(s).encode(encoding, errors)
        elif not isinstance(s, basestring):
            try:
                return str(s)
            except UnicodeEncodeError:
                if isinstance(s, Exception):
                    # An Exception subclass containing non-ASCII data that doesn't
                    # know how to print itself properly. We shouldn't raise a
                    # further exception.
                    return ' '.join([smart_str(arg, encoding, strings_only,
                            errors) for arg in s])
                return unicode(s).encode(encoding, errors)
        elif isinstance(s, unicode):
            return s.encode(encoding, errors)
        elif s and encoding != 'utf-8':
            return s.decode('utf-8', errors).encode(encoding, errors)
        else:
            return s
    
    class Promise(object):
        """
        This is just a base class for the proxy class created in
        the closure of the lazy function. It can be used to recognize
        promises in code.
        """
        pass
    
    def get_language():
        return real_get_language()
    


Answer: You are using only `formats` and `force_unicode`. Just copy these into your
code and get rid of all imports.

