mirrors
/
django
mirror of https://github.com/django/django.git
1
0
Fork 0
Code Issues 16 Releases Wiki Activity

Django coding style fixes. 

git-svn-id: http://code.djangoproject.com/svn/django/trunk@6528 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
Gary Wilson Jr 2007-10-19 01:26:09 +00:00
parent 73f495158c
commit 088cb3c2f3
2 changed files with 88 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
django/core/management/__init__.py
View File

@ -1,10 +1,11 @@
import django
from django.core.management.base import BaseCommand, CommandError, handle_default_options
from optparse import OptionParser
import os import os
import sys import sys
from optparse import OptionParser
from imp import find_module from imp import find_module
import django
from django.core.management.base import BaseCommand, CommandError, handle_default_options
# For backwards compatibility: get_version() used to be in this module. # For backwards compatibility: get_version() used to be in this module.
get_version = django.get_version get_version = django.get_version
@ -14,18 +15,21 @@ _commands = None
def find_commands(management_dir): def find_commands(management_dir):
""" """
Given a path to a management directory, return a list of all the command names Given a path to a management directory, returns a list of all the command
that are available. Returns an empty list if no commands are defined. names that are available.
Returns an empty list if no commands are defined.
""" """
command_dir = os.path.join(management_dir,'commands') command_dir = os.path.join(management_dir, 'commands')
try: try:
return [f[:-3] for f in os.listdir(command_dir) if not f.startswith('_') and f.endswith('.py')] return [f[:-3] for f in os.listdir(command_dir)
if not f.startswith('_') and f.endswith('.py')]
except OSError: except OSError:
return [] return []
def find_management_module(app_name): def find_management_module(app_name):
""" """
Determine the path to the management module for the application named, Determines the path to the management module for the application named,
without acutally importing the application or the management module. without acutally importing the application or the management module.
Raises ImportError if the management module cannot be found for any reason. Raises ImportError if the management module cannot be found for any reason.
@ -36,7 +40,7 @@ def find_management_module(app_name):
path = None path = None
while parts: while parts:
part = parts.pop() part = parts.pop()
f,path,descr = find_module(part, path and [path] or None) f, path, descr = find_module(part, path and [path] or None)
return path return path
def load_command_class(app_name, name): def load_command_class(app_name, name):
@ -77,7 +81,7 @@ def get_commands(load_user_commands=True, project_directory=None):
_commands = dict([(name, 'django.core') _commands = dict([(name, 'django.core')
for name in find_commands(__path__[0])]) for name in find_commands(__path__[0])])
if load_user_commands: if load_user_commands:
# Get commands from all installed apps # Get commands from all installed apps.
from django.conf import settings from django.conf import settings
for app_name in settings.INSTALLED_APPS: for app_name in settings.INSTALLED_APPS:
try: try:
@ -150,10 +154,13 @@ class ManagementUtility(object):
Returns the script's main help text, as a string. Returns the script's main help text, as a string.
""" """
usage = ['%s <subcommand> [options] [args]' % self.prog_name] usage = ['%s <subcommand> [options] [args]' % self.prog_name]
usage.append('Django command line tool, version %s' % django.get_version()) usage.append('Django command line tool,'
usage.append("Type '%s help <subcommand>' for help on a specific subcommand." % self.prog_name) ' version %s' % django.get_version())
usage.append("Type '%s help <subcommand>' for help on a specific"
" subcommand." % self.prog_name)
usage.append('Available subcommands:') usage.append('Available subcommands:')
commands = get_commands(self.user_commands, self.project_directory).keys() commands = get_commands(self.user_commands,
self.project_directory).keys()
commands.sort() commands.sort()
for cmd in commands: for cmd in commands:
usage.append(' %s' % cmd) usage.append(' %s' % cmd)
@ -166,14 +173,16 @@ class ManagementUtility(object):
django-admin.py or manage.py) if it can't be found. django-admin.py or manage.py) if it can't be found.
""" """
try: try:
app_name = get_commands(self.user_commands, self.project_directory)[subcommand] app_name = get_commands(self.user_commands,
self.project_directory)[subcommand]
if isinstance(app_name, BaseCommand): if isinstance(app_name, BaseCommand):
# If the command is already loaded, use it directly. # If the command is already loaded, use it directly.
klass = app_name klass = app_name
else: else:
klass = load_command_class(app_name, subcommand) klass = load_command_class(app_name, subcommand)
except KeyError: except KeyError:
sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" % (subcommand, self.prog_name)) sys.stderr.write("Unknown command: %r\nType '%s help' for"
" usage.\n" % (subcommand, self.prog_name))
sys.exit(1) sys.exit(1)
return klass return klass
@ -182,9 +191,9 @@ class ManagementUtility(object):
Given the command-line arguments, this figures out which subcommand is Given the command-line arguments, this figures out which subcommand is
being run, creates a parser appropriate to that command, and runs it. being run, creates a parser appropriate to that command, and runs it.
""" """
# Preprocess options to extract --settings and --pythonpath. These options # Preprocess options to extract --settings and --pythonpath.
# could affect the commands that are available, so they must be processed # These options could affect the commands that are available, so they
# early # must be processed early.
parser = LaxOptionParser(version=get_version(), parser = LaxOptionParser(version=get_version(),
option_list=BaseCommand.option_list) option_list=BaseCommand.option_list)
try: try:
@ -230,7 +239,7 @@ class ProjectManagementUtility(ManagementUtility):
def setup_environ(settings_mod): def setup_environ(settings_mod):
""" """
Configure the runtime environment. This can also be used by external Configures the runtime environment. This can also be used by external
scripts wanting to set up a similar environment to manage.py. scripts wanting to set up a similar environment to manage.py.
""" """
# Add this project to sys.path so that it's importable in the conventional # Add this project to sys.path so that it's importable in the conventional
@ -244,7 +253,8 @@ def setup_environ(settings_mod):
sys.path.pop() sys.path.pop()
# Set DJANGO_SETTINGS_MODULE appropriately. # Set DJANGO_SETTINGS_MODULE appropriately.
os.environ['DJANGO_SETTINGS_MODULE'] = '%s.%s' % (project_name, settings_name) os.environ['DJANGO_SETTINGS_MODULE'] = '%s.%s' % (project_name,
settings_name)
return project_directory return project_directory
def execute_from_command_line(argv=None): def execute_from_command_line(argv=None):

47
django/utils/datastructures.py
View File

@ -46,18 +46,21 @@ class MergeDict(object):
__contains__ = has_key __contains__ = has_key
def copy(self): def copy(self):
""" returns a copy of this object""" """Returns a copy of this object."""
return self.__copy__() return self.__copy__()
class SortedDict(dict): class SortedDict(dict):
"A dictionary that keeps its keys in the order in which they're inserted." """
A dictionary that keeps its keys in the order in which they're inserted.
"""
def __init__(self, data=None): def __init__(self, data=None):
if data is None: data = {} if data is None:
data = {}
dict.__init__(self, data) dict.__init__(self, data)
if isinstance(data, dict): if isinstance(data, dict):
self.keyOrder = data.keys() self.keyOrder = data.keys()
else: else:
self.keyOrder=[key for key, value in data] self.keyOrder = [key for key, value in data]
def __setitem__(self, key, value): def __setitem__(self, key, value):
dict.__setitem__(self, key, value) dict.__setitem__(self, key, value)
@ -102,20 +105,21 @@ class SortedDict(dict):
return dict.setdefault(self, key, default) return dict.setdefault(self, key, default)
def value_for_index(self, index): def value_for_index(self, index):
"Returns the value of the item at the given zero-based index." """Returns the value of the item at the given zero-based index."""
return self[self.keyOrder[index]] return self[self.keyOrder[index]]
def insert(self, index, key, value): def insert(self, index, key, value):
"Inserts the key, value pair before the item with the given index." """Inserts the key, value pair before the item with the given index."""
if key in self.keyOrder: if key in self.keyOrder:
n = self.keyOrder.index(key) n = self.keyOrder.index(key)
del self.keyOrder[n] del self.keyOrder[n]
if n < index: index -= 1 if n < index:
index -= 1
self.keyOrder.insert(index, key) self.keyOrder.insert(index, key)
dict.__setitem__(self, key, value) dict.__setitem__(self, key, value)
def copy(self): def copy(self):
"Returns a copy of this object." """Returns a copy of this object."""
# This way of initializing the copy means it works for subclasses, too. # This way of initializing the copy means it works for subclasses, too.
obj = self.__class__(self) obj = self.__class__(self)
obj.keyOrder = self.keyOrder obj.keyOrder = self.keyOrder
@ -133,7 +137,8 @@ class MultiValueDictKeyError(KeyError):
class MultiValueDict(dict): class MultiValueDict(dict):
""" """
A subclass of dictionary customized to handle multiple values for the same key. A subclass of dictionary customized to handle multiple values for the
same key.
>>> d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer']}) >>> d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer']})
>>> d['name'] >>> d['name']
@ -176,15 +181,17 @@ class MultiValueDict(dict):
def __deepcopy__(self, memo=None): def __deepcopy__(self, memo=None):
import copy import copy
if memo is None: memo = {} if memo is None:
memo = {}
result = self.__class__() result = self.__class__()
memo[id(self)] = result memo[id(self)] = result
for key, value in dict.items(self): for key, value in dict.items(self):
dict.__setitem__(result, copy.deepcopy(key, memo), copy.deepcopy(value, memo)) dict.__setitem__(result, copy.deepcopy(key, memo),
copy.deepcopy(value, memo))
return result return result
def get(self, key, default=None): def get(self, key, default=None):
"Returns the default value if the requested data doesn't exist" """Returns the default value if the requested data doesn't exist."""
try: try:
val = self[key] val = self[key]
except KeyError: except KeyError:
@ -194,7 +201,7 @@ class MultiValueDict(dict):
return val return val
def getlist(self, key): def getlist(self, key):
"Returns an empty list if the requested data doesn't exist" """Returns an empty list if the requested data doesn't exist."""
try: try:
return dict.__getitem__(self, key) return dict.__getitem__(self, key)
except KeyError: except KeyError:
@ -214,7 +221,7 @@ class MultiValueDict(dict):
return self.getlist(key) return self.getlist(key)
def appendlist(self, key, value): def appendlist(self, key, value):
"Appends an item to the internal list associated with key" """Appends an item to the internal list associated with key."""
self.setlistdefault(key, []) self.setlistdefault(key, [])
dict.__setitem__(self, key, self.getlist(key) + [value]) dict.__setitem__(self, key, self.getlist(key) + [value])
@ -226,19 +233,22 @@ class MultiValueDict(dict):
return [(key, self[key]) for key in self.keys()] return [(key, self[key]) for key in self.keys()]
def lists(self): def lists(self):
"Returns a list of (key, list) pairs." """Returns a list of (key, list) pairs."""
return dict.items(self) return dict.items(self)
def values(self): def values(self):
"Returns a list of the last value on every key list." """Returns a list of the last value on every key list."""
return [self[key] for key in self.keys()] return [self[key] for key in self.keys()]
def copy(self): def copy(self):
"Returns a copy of this object." """Returns a copy of this object."""
return self.__deepcopy__() return self.__deepcopy__()
def update(self, *args, **kwargs): def update(self, *args, **kwargs):
"update() extends rather than replaces existing key lists. Also accepts keyword args." """
update() extends rather than replaces existing key lists.
Also accepts keyword args.
"""
if len(args) > 1: if len(args) > 1:
raise TypeError, "update expected at most 1 arguments, got %d" % len(args) raise TypeError, "update expected at most 1 arguments, got %d" % len(args)
if args: if args:
@ -299,4 +309,3 @@ class FileDict(dict):
d = dict(self, content='<omitted>') d = dict(self, content='<omitted>')
return dict.__repr__(d) return dict.__repr__(d)
return dict.__repr__(self) return dict.__repr__(self)