├── utils
    ├── __init__.py
    ├── pathhelpers.py
    ├── pathutils.py
    ├── datetimehelpers.py
    └── peewee.py
├── res
    ├── .DS_Store
    ├── drawable
    │   ├── 0.png
    │   ├── 10.png
    │   ├── 20.png
    │   ├── 30.png
    │   ├── 40.png
    │   ├── 50.png
    │   ├── 60.png
    │   ├── 70.png
    │   ├── 80.png
    │   ├── 90.png
    │   ├── 100.png
    │   ├── 110.png
    │   ├── 120.png
    │   ├── 130.png
    │   ├── 140.png
    │   ├── 150.png
    │   ├── 160.png
    │   ├── 170.png
    │   ├── 180.png
    │   ├── 190.png
    │   ├── 200.png
    │   └── logo.png
    └── layout
    │   ├── main.xml
    │   └── addmealscreen.xml
├── data
    └── caloriesdb.db3
├── screenshot
    ├── calories1.jpg
    └── calories2.jpg
├── README.md
├── caloriesdb.py
└── main.py


/utils/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/res/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/.DS_Store


--------------------------------------------------------------------------------
/data/caloriesdb.db3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/data/caloriesdb.db3


--------------------------------------------------------------------------------
/res/drawable/0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/0.png


--------------------------------------------------------------------------------
/res/drawable/10.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/10.png


--------------------------------------------------------------------------------
/res/drawable/20.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/20.png


--------------------------------------------------------------------------------
/res/drawable/30.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/30.png


--------------------------------------------------------------------------------
/res/drawable/40.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/40.png


--------------------------------------------------------------------------------
/res/drawable/50.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/50.png


--------------------------------------------------------------------------------
/res/drawable/60.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/60.png


--------------------------------------------------------------------------------
/res/drawable/70.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/70.png


--------------------------------------------------------------------------------
/res/drawable/80.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/80.png


--------------------------------------------------------------------------------
/res/drawable/90.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/90.png


--------------------------------------------------------------------------------
/res/drawable/100.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/100.png


--------------------------------------------------------------------------------
/res/drawable/110.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/110.png


--------------------------------------------------------------------------------
/res/drawable/120.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/120.png


--------------------------------------------------------------------------------
/res/drawable/130.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/130.png


--------------------------------------------------------------------------------
/res/drawable/140.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/140.png


--------------------------------------------------------------------------------
/res/drawable/150.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/150.png


--------------------------------------------------------------------------------
/res/drawable/160.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/160.png


--------------------------------------------------------------------------------
/res/drawable/170.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/170.png


--------------------------------------------------------------------------------
/res/drawable/180.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/180.png


--------------------------------------------------------------------------------
/res/drawable/190.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/190.png


--------------------------------------------------------------------------------
/res/drawable/200.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/200.png


--------------------------------------------------------------------------------
/res/drawable/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/res/drawable/logo.png


--------------------------------------------------------------------------------
/screenshot/calories1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/screenshot/calories1.jpg


--------------------------------------------------------------------------------
/screenshot/calories2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qpython-android/qpy-calcount/HEAD/screenshot/calories2.jpg


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # About
 2 | 
 3 | QPyCalCount is a sample project for QPython which show how to use QSL4A features.
 4 | 
 5 | 
 6 | ## Runtime Screenshot
 7 | 
 8 | ![Main screen](https://github.com/qpython-android/qpy-calcount/blob/master/screenshot/calories2.jpg?raw=true "Main screen")
 9 | ![Add a Meal](https://github.com/qpython-android/qpy-calcount/blob/master/screenshot/calories1.jpg?raw=true "Add a Meal")
10 | 
11 | 
12 | 
13 | ## How to run
14 | 
15 | Please checkout this project and put it on the /sdcard/qpython/projects.
16 | 
17 | You need to install qsl4ahelper-qpython2/qsl4ahelper-qpython with QPYPI before running it.
18 | 
19 | ```
20 | pip install qsl4ahelper-qpython2
21 | 
22 | ```
23 | 
24 | Then you can run it from QPython's Quick Start.
25 | 
26 | 
27 | ## Introduction
28 | 
29 | Author: Hariharan Srinath
30 | 
31 | It's based on the [FullScreenWrapper2: An Python SL4A GUI framework for Android](http://srinathh.github.io/opensource/fullscreenwrapper/)
32 | 
33 | ## We need your help
34 | It could be ported to QPython3 easily. You can try to port qsl4ahelper-qpython2 to qpython3 first. That will be great if you are interested in helping this.
35 | 


--------------------------------------------------------------------------------
/utils/pathhelpers.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Created on Jul 24, 2012
 3 | 
 4 | @author: Admin
 5 | '''
 6 | 
 7 | import os.path
 8 | import pathutils
 9 | 
10 | RESOURCE_TYPE_LAYOUT = ["res","layout"]
11 | RESOURCE_TYPE_DRAWABLE = ["res","drawable"]
12 | RESOURCE_TYPE_DATA = ["data",]
13 | 
14 | def get_resource_pathname(resource_filename, resource_type):
15 |     retpath = pathutils.get_exec_file_dir()
16 |     for subdir in resource_type:
17 |         retpath = os.path.join(retpath,subdir)
18 | 
19 |     return os.path.join(retpath,resource_filename)
20 | 
21 | def get_drawable_pathname(drawable_filename):
22 |     return "file://"+get_resource_pathname(drawable_filename, RESOURCE_TYPE_DRAWABLE)
23 | 
24 | def get_layout_pathname(layout_filename):
25 |     return get_resource_pathname(layout_filename, RESOURCE_TYPE_LAYOUT)
26 | 
27 | def get_data_pathname(data_filename):
28 |     return get_resource_pathname(data_filename, RESOURCE_TYPE_DATA)
29 | 
30 | def read_layout_xml(layout_filename):
31 |     fil = open(get_layout_pathname(layout_filename))
32 |     xmldata = fil.read()
33 |     fil.close()
34 |     return xmldata
35 | 
36 | if __name__ == '__main__':
37 |     print get_data_pathname("abc.db3")
38 | 


--------------------------------------------------------------------------------
/utils/pathutils.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | import os.path
 4 | 
 5 | def get_filepath_in_exec_file_dir(filename):
 6 |     return os.path.join(get_exec_file_dir(), filename)
 7 | 
 8 | def get_exec_file_dir():
 9 |     return os.path.dirname(unicode(sys.argv[0]))
10 | 
11 | def get_exec_file_parent_dir():
12 |     return os.path.split(unicode(os.path.dirname(sys.argv[0])))[0]
13 | 
14 | def get_extension(filename):
15 |     return os.path.splitext(unicode(filename))[1]
16 | 
17 | def get_extension_lowercase(filename):
18 |     return get_extension(unicode(filename)).lower()
19 | 
20 | def get_filename_without_extension_or_path(filename):
21 |     i = os.path.split(filename)[1]
22 |     return os.path.splitext(i)[0]
23 | 
24 | def walk_filenames_by_extension(root, extension_list):
25 |     """
26 |     Walks down the root directory & matches files with specified extensions. Returns list of file-paths
27 |     IMPORTANT: This converts extensions to lowercase before comparison (windows behavior)
28 |     """
29 |     ret = []
30 |     for extension in extension_list:
31 |         if(extension[0]!="."):
32 |             use_ext = "."+extension
33 |         else:
34 |             use_ext = extension
35 | 
36 |         for dirpath, dirnames,  filenames in os.walk(root):
37 |             for filename in filenames:
38 |                 if get_extension_lowercase(filename)==use_ext.lower():
39 |                     ret.append(os.path.join(dirpath,filename))
40 | 
41 |     return ret
42 | 


--------------------------------------------------------------------------------
/utils/datetimehelpers.py:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------------------------------------
 2 | # Name:        module1
 3 | # Purpose:
 4 | #
 5 | # Author:      srinath.h
 6 | #
 7 | # Created:     13/05/2012
 8 | # Copyright:   (c) srinath.h 2012
 9 | # Licence:     <your licence>
10 | #-------------------------------------------------------------------------------
11 | #!/usr/bin/env python
12 | 
13 | import datetime
14 | 
15 | def get_full_day_datetime_range(curdatetime):
16 |     startdatetimerange = datetime.datetime.combine(curdatetime.date(),datetime.time(0,0,0))
17 |     enddatetimerange = datetime.datetime.combine(curdatetime.date(),datetime.time(23,59,59))
18 |     return (startdatetimerange,enddatetimerange)
19 | 
20 | def get_full_week_datetime_range(curdatetime):
21 |     weekstuff = {6:(0,6),0:(-1,5),1:(-2,4),2:(-3,3),3:(-4,2),4:(-5,1),5:(-6,0)}
22 |     curdate = curdatetime.date()
23 |     curweekday = curdate.weekday()
24 |     startdatetimerange = datetime.datetime.combine(curdate+datetime.timedelta(weekstuff[curweekday][0]),datetime.time(0,0,0))
25 |     enddatetimerange =datetime.datetime.combine(curdate+datetime.timedelta(weekstuff[curweekday][1]),datetime.time(23,59,59))
26 |     return(startdatetimerange,enddatetimerange)
27 | 
28 | def get_full_month_datetime_range(curdatetime):
29 |     curmonth = curdatetime.month
30 |     newmonth = curmonth
31 |     wrkdatetime = curdatetime
32 |     td = datetime.timedelta(1)
33 | 
34 |     while(newmonth==curmonth):
35 |         wrkdatetime += td
36 |         newmonth = wrkdatetime.month
37 | 
38 |     wrkdatetime -= td
39 |     lastdate = wrkdatetime.day
40 |     curyear = curdatetime.year
41 | 
42 |     startdatetimerange = datetime.datetime.combine(datetime.date(curyear, curmonth,1),datetime.time(0,0,0))
43 |     enddatetimerange = datetime.datetime.combine(datetime.date(curyear,curmonth,lastdate),datetime.time(23,59,59))
44 |     return(startdatetimerange,enddatetimerange)
45 | 


--------------------------------------------------------------------------------
/res/layout/main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout
 3 | 	android:layout_width="fill_parent"
 4 | 	android:layout_height="fill_parent"
 5 | 	android:background="#ff314859"
 6 | 	android:orientation="vertical"
 7 | 	xmlns:android="http://schemas.android.com/apk/res/android">
 8 | 	<ImageView
 9 | 		android:id="@+id/logo"
10 | 		android:layout_width="fill_parent"
11 | 		android:layout_height="0px"
12 | 		android:layout_weight="10"
13 | 	/>
14 | 	<LinearLayout
15 | 		android:layout_width="fill_parent"
16 | 		android:layout_height="0px"
17 | 		android:orientation="horizontal"
18 | 		android:layout_weight="20">
19 | 		<TextView
20 | 			android:layout_width="fill_parent"
21 | 			android:layout_height="fill_parent"
22 | 			android:textSize="8dp"
23 | 			android:text="Today :"
24 | 			android:textColor="#ffffffff"
25 | 			android:layout_weight="1"
26 | 			android:gravity="center"
27 | 		/>
28 | 		<ImageView
29 | 			android:id="@+id/todaycal"
30 | 			android:layout_width="fill_parent"
31 | 			android:layout_height="fill_parent"
32 | 			android:layout_weight="1"
33 | 		/>
34 | 		<TextView
35 | 			android:layout_width="fill_parent"
36 | 			android:layout_height="fill_parent"
37 | 			android:textSize="8dp"
38 | 			android:text="Week :"
39 | 			android:textColor="#ffffffff"
40 | 			android:layout_weight="1"
41 | 			android:gravity="center"
42 | 		/>
43 | 		<ImageView
44 | 			android:id="@+id/weekcal"
45 | 			android:layout_width="fill_parent"
46 | 			android:layout_height="fill_parent"
47 | 			android:layout_weight="1"
48 | 		/>	
49 | 	</LinearLayout>
50 | 	<ListView
51 | 		android:id="@+id/lst_today_meals"
52 | 		android:layout_width="fill_parent"
53 | 		android:layout_height="0px"
54 | 		android:layout_weight="55"/>
55 | 	<LinearLayout
56 | 		android:layout_width="fill_parent"
57 | 		android:layout_height="0px"
58 | 		android:orientation="horizontal"
59 | 		android:layout_weight="15">
60 | 		<Button
61 | 			android:layout_width="fill_parent"
62 | 			android:layout_height="fill_parent"
63 | 			android:text="Add"
64 | 			android:id="@+id/but_add" 
65 | 			android:textSize="8dp"
66 | 			android:background="#ff25567b"
67 | 			android:textColor="#ffffffff"
68 | 			android:layout_weight="1"
69 | 			android:gravity="center"/>
70 | 		<Button
71 | 			android:layout_width="fill_parent"
72 | 			android:layout_height="fill_parent"
73 | 			android:text="Last 7 Days"
74 | 			android:id="@+id/but_lookup" 
75 | 			android:textSize="8dp"
76 | 			android:background="#ff66a3d2"
77 | 			android:textColor="#ffffffff"
78 | 			android:layout_weight="1"
79 | 			android:gravity="center"/>
80 | 		<Button
81 | 			android:layout_width="fill_parent"
82 | 			android:layout_height="fill_parent"
83 | 			android:text="Exit"
84 | 			android:id="@+id/but_exit" 
85 | 			android:textSize="8dp"
86 | 			android:background="#ff25567b"
87 | 			android:textColor="#ffffffff"
88 | 			android:layout_weight="1"
89 | 			android:gravity="center"/>
90 | 	</LinearLayout>
91 | </LinearLayout>
92 | 


--------------------------------------------------------------------------------
/caloriesdb.py:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------------------------------------
 2 | # Name:        caloriesdb
 3 | # Purpose:
 4 | #
 5 | # Author:      srinath.h
 6 | #
 7 | # Created:     23/05/2012
 8 | # Copyright:   (c) srinath.h 2012
 9 | # Licence:     <your licence>
10 | #-------------------------------------------------------------------------------
11 | #!/usr/bin/env python
12 | 
13 | import datetime
14 | import sys
15 | import os
16 | import os.path
17 | import random
18 | from utils import pathhelpers
19 | from utils import datetimehelpers
20 | from utils.peewee import *
21 | 
22 | #print pathhelpers.get_data_pathname("caloriesdb.db3")
23 | _mydatabase = SqliteDatabase( pathhelpers.get_data_pathname("caloriesdb.db3"))
24 | _mydatabase.connect()
25 | 
26 | class BaseDB(Model):
27 |     class Meta:
28 |         database = _mydatabase
29 | 
30 | class Calories(BaseDB):
31 |     mealtime = DateTimeField()
32 |     calories = IntegerField()
33 |     fooditem = CharField()
34 | 
35 |     def __str__(self):
36 |         txt =str(self.calories)+" KCal, " + self.mealtime.time().isoformat()[:5]
37 |         if(len(self.fooditem)>0):
38 |             txt +=", "+self.fooditem
39 | 
40 |         return txt
41 | 
42 |     class TimeRange:
43 |         DAY = 1
44 |         WEEK = 2
45 |         MONTH = 3
46 |     
47 |     @classmethod
48 |     def delete_entry(self,meal):
49 |         delquery = self.delete().where(Q(mealtime=meal.mealtime)&Q(calories=meal.calories))
50 |         delquery.execute()
51 | 
52 |     @classmethod
53 |     def _get_date_time_range(self,timerange,ref_datetime):
54 |         if(timerange==self.TimeRange.DAY):
55 |             return datetimehelpers.get_full_day_datetime_range(ref_datetime)
56 |         elif(timerange==self.TimeRange.WEEK):
57 |             return datetimehelpers.get_full_week_datetime_range(ref_datetime)
58 |         elif(timerange==self.TimeRange.MONTH):
59 |             return datetimehelpers.get_full_month_datetime_range(ref_datetime)
60 |         else:
61 |             raise AttributeError("The timerange specified must be one of TimeRange.DAY, TimeRange.WEEK, TimeRange.MONTH")
62 | 
63 |     @classmethod
64 |     def get_meals(self, timerange, ref_datetime=datetime.datetime.now()):
65 |         startdatetime,enddatetime = self._get_date_time_range(timerange,ref_datetime)
66 |         return self.select().where(Q(mealtime__gte=startdatetime) & Q(mealtime__lte=enddatetime)).order_by(('mealtime', 'desc'))
67 | 
68 |     @classmethod
69 |     def get_calories(self, timerange, ref_datetime=datetime.datetime.now()):
70 |         startdatetime,enddatetime = self._get_date_time_range(timerange,ref_datetime)
71 |         ret = self.select().where(Q(mealtime__gte=startdatetime) & Q(mealtime__lte=enddatetime)).aggregate(Sum("calories"))
72 |         if(ret == None):
73 |             ret = 0
74 | 
75 |         return ret
76 | 
77 |     @classmethod
78 |     def gen_testcases(self):
79 |         for j in range(29,-1,-1):
80 |             td = datetime.timedelta(j)
81 |             enterdate = datetime.datetime.today().date()-td
82 |             num_meals = random.randint(5,8)
83 |             for k in range(num_meals):
84 |                 cal = random.randint(40,450)
85 |                 hrs = random.randint(7,23)
86 |                 mins = random.randint(1,59)
87 |                 enterdatetime = datetime.datetime.combine(enterdate,datetime.time(hrs,mins))
88 |                 self.create(mealtime = enterdatetime, calories = cal, fooditem = "", comment = "")
89 | 
90 | Calories.create_table(True)
91 | 


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | #qpy:quiet
  2 | '''
  3 | This is an example with how to use SL4A APIs to develop a  ANDROID NATIVE App
  4 | 
  5 | Please put this project into /sdcard/qpython/projects/
  6 | 
  7 | You need to install qsl4ahelper-qpython2 before running this project
  8 | '''
  9 | 
 10 | from qsl4ahelper.fullscreenwrapper2 import *
 11 | import androidhelper
 12 | import datetime
 13 | import os
 14 | import caloriesdb
 15 | from caloriesdb import Calories
 16 | from utils import pathhelpers
 17 | import sys
 18 | import time
 19 | 
 20 | droid = androidhelper.Android()
 21 | 
 22 | class AddMealScreen(Layout):
 23 |     def __init__(self):
 24 |         #initialize your class data attributes
 25 |         self._add_datetime = None
 26 |         self._add_calories = None
 27 |         #load and set your xml
 28 |         super(AddMealScreen,self).__init__(pathhelpers.read_layout_xml("addmealscreen.xml"),"Add a Meal")
 29 | 
 30 |     def on_show(self):
 31 |         curdatetime = datetime.datetime.now()
 32 | 
 33 |         self.views.add_meal_txt_date.text = curdatetime.date().isoformat()
 34 |         self.views.add_meal_txt_time.text = curdatetime.time().isoformat()[0:5]
 35 | 
 36 |         self.add_event(key_EventHandler("4", self,self.cancel ))
 37 |         self.views.but_datechange.add_event(click_EventHandler(self.views.but_datechange, self.datechange))
 38 |         self.views.but_timechange.add_event(click_EventHandler(self.views.but_timechange, self.timechange))
 39 |         self.views.but_save.add_event(click_EventHandler(self.views.but_save, self.save))
 40 |         self.views.but_lookup.add_event(click_EventHandler(self.views.but_lookup, self.lookup))
 41 | 
 42 |         self.views.but_add_40.add_event(click_EventHandler(self.views.but_add_40, self.set_calories_to))
 43 |         self.views.but_add_70.add_event(click_EventHandler(self.views.but_add_70, self.set_calories_to))
 44 |         self.views.but_add_100.add_event(click_EventHandler(self.views.but_add_100, self.set_calories_to))
 45 |         self.views.but_add_120.add_event(click_EventHandler(self.views.but_add_120, self.set_calories_to))
 46 |         self.views.but_add_150.add_event(click_EventHandler(self.views.but_add_150, self.set_calories_to))
 47 |         self.views.but_add_180.add_event(click_EventHandler(self.views.but_add_180, self.set_calories_to))
 48 |         self.views.but_add_200.add_event(click_EventHandler(self.views.but_add_200, self.set_calories_to))
 49 |         self.views.but_add_250.add_event(click_EventHandler(self.views.but_add_250, self.set_calories_to))
 50 |         self.views.but_add_300.add_event(click_EventHandler(self.views.but_add_300, self.set_calories_to))
 51 |         self.views.but_add_350.add_event(click_EventHandler(self.views.but_add_350, self.set_calories_to))
 52 |         self.views.but_add_400.add_event(click_EventHandler(self.views.but_add_400, self.set_calories_to))
 53 |         self.views.but_add_450.add_event(click_EventHandler(self.views.but_add_450, self.set_calories_to))
 54 | 
 55 |     def on_close(self):
 56 |         pass
 57 | 
 58 |     def cancel(self,view,eventdata):
 59 |         FullScreenWrapper2App.close_layout()
 60 | 
 61 |     def datechange(self, view, eventdata):
 62 |         curdateentry = self.views.add_meal_txt_date.text
 63 |         droid = FullScreenWrapper2App.get_android_instance()
 64 |         droid.dialogCreateDatePicker(int(curdateentry[:4]),int(curdateentry[5:7]),int(curdateentry[8:10]))
 65 |         droid.dialogShow()
 66 |         response=droid.dialogGetResponse().result
 67 |         droid.dialogDismiss()
 68 |         cur = datetime.date(response["year"],response['month'],response['day'])
 69 |         self.views.add_meal_txt_date.text = cur.isoformat()
 70 | 
 71 | 
 72 |     def timechange(self,view,eventdata):
 73 |         curtimeentry = self.views.add_meal_txt_time.text
 74 |         droid = FullScreenWrapper2App.get_android_instance()
 75 |         droid.dialogCreateTimePicker(int(curtimeentry[0:2]),int(curtimeentry [3:5]),True)
 76 |         droid.dialogShow()
 77 |         response=droid.dialogGetResponse().result
 78 |         droid.dialogDismiss()
 79 |         cur = datetime.time(response["hour"],response['minute'])
 80 |         self.views.add_meal_txt_time.text = cur.isoformat()[0:5]
 81 | 
 82 |     def lookup(self,view,evemtdata):
 83 |         FullScreenWrapper2App.get_android_instance().makeToast("lookup yet to be implemented")
 84 | 
 85 |     def save(self,view,evemtdata):
 86 |         #FullScreenWrapper2App.get_android_instance().makeToast("Save yet to be implemented")
 87 |         calstext = self.views.add_meal_txt_calories.text
 88 |         if(calstext.isdigit()):
 89 |             datetext =self.views.add_meal_txt_date.text
 90 |             adddate = datetime.date(int(datetext[0:4]),int(datetext[5:7]),int(datetext[8:10]))
 91 |             timetext =self.views.add_meal_txt_time.text
 92 |             addtime = datetime.time(int(timetext[0:2]),int(timetext[3:5]))
 93 |             adddatetime = datetime.datetime.combine(adddate,addtime)
 94 | 
 95 |             addfooditemtext = self.views.add_meal_txt_fooditem.text
 96 |             addcals = int(calstext)
 97 | 
 98 |             cals = caloriesdb.Calories()
 99 |             cals.create(mealtime = adddatetime, calories = addcals, fooditem = addfooditemtext)
100 |             FullScreenWrapper2App.get_android_instance().makeToast("Saving")
101 |             FullScreenWrapper2App.close_layout()
102 |         else:
103 |             FullScreenWrapper2App.get_android_instance().makeToast("You must enter a valid number for calories")
104 | 
105 |     def set_calories_to(self,view,evemtdata):
106 |         self.views.add_meal_txt_calories.text = view.text
107 |         #FullScreenWrapper2App.get_android_instance().makeToast("set_calories_to yet to be implemented")
108 | 
109 | 
110 | class MainScreen(Layout):
111 |     def __init__(self):
112 |         #initialize your class data attributes
113 |         self.max_cals_per_day = 2000
114 |         self.show_meals_list =[]
115 |         self.lst_view_items =[]
116 |         self.view_day = True
117 |         #load & set your xml
118 |         super(MainScreen,self).__init__(pathhelpers.read_layout_xml("main.xml"),"CalCount")
119 | 
120 |     def on_show(self):
121 |         #initialize your layout views on screen_show
122 |         self.views.logo.src = pathhelpers.get_drawable_pathname("logo.png")
123 |         self.update_todays_meals_list()
124 | 
125 |         #setup the event handlers for your layout views
126 |         self.views.but_exit.add_event(click_EventHandler(self.views.but_exit, self.close_out))
127 |         self.views.but_add.add_event(click_EventHandler(self.views.but_add,self.add_meal))
128 |         self.views.lst_today_meals.add_event(itemclick_EventHandler(self.views.lst_today_meals, self.mealitem_click))
129 |         self.add_event(key_EventHandler("4", self,self.close_out ))
130 |         self.views.but_lookup.add_event(click_EventHandler(self.views.but_lookup, self.flip_today_7_days))
131 | 
132 |     def flip_today_7_days(self,view, eventdata):
133 |         self.view_day = not self.view_day
134 |         self.on_show()
135 | 
136 |     def on_close(self):
137 |         pass
138 | 
139 |     def mealitem_click(self,view,eventdata):
140 |         if not self.view_day:
141 |             return
142 | 
143 |         position = int(eventdata["data"]["position"])
144 |         FullScreenWrapper2App.get_android_instance().dialogCreateAlert("Do you want to delete the meal - "+str(self.show_meals_list[position]))
145 |         FullScreenWrapper2App.get_android_instance().dialogSetPositiveButtonText("Yes")
146 |         FullScreenWrapper2App.get_android_instance().dialogSetNegativeButtonText("No")
147 |         FullScreenWrapper2App.get_android_instance().dialogShow()
148 |         response=FullScreenWrapper2App.get_android_instance().dialogGetResponse().result
149 |         FullScreenWrapper2App.get_android_instance().dialogDismiss()
150 | 
151 |         try:
152 |             if response["which"]=="positive":
153 |                 Calories.delete_entry(self.show_meals_list[position])
154 |         except:
155 |             pass
156 | 
157 |         self.update_todays_meals_list()
158 |         FullScreenWrapper2App.get_android_instance().makeToast("Deleting...")
159 | 
160 | 
161 |     def add_meal(self,view,eventdata):
162 |         FullScreenWrapper2App.show_layout(AddMealScreen())
163 | 
164 |     def close_out(self,view,event ):
165 |         FullScreenWrapper2App.close_layout()
166 | 
167 |     def update_todays_meals_list(self):
168 |         self.show_meals_list =[]
169 |         self.lst_view_items =[]
170 | 
171 |         if self.view_day:
172 |             for meal in Calories.get_meals(Calories.TimeRange.DAY):
173 |                 self.show_meals_list.append(meal)
174 |                 self.lst_view_items.append(str(meal))
175 | 
176 |             self.views.but_lookup.text = "Last 7 Days"
177 |         else:
178 |             curdate = datetime.datetime.today()
179 |             for j in range(7):
180 |                 curdate = curdate - datetime.timedelta(j)
181 |                 cals = Calories.get_calories(Calories.TimeRange.DAY, curdate)
182 |                 text = curdate.date().isoformat() + "-"+str(cals)
183 |                 self.show_meals_list.append(text)
184 |                 self.lst_view_items.append(text)
185 |             self.views.but_lookup.text = "Today"
186 | 
187 |         self.views.lst_today_meals.set_listitems(self.lst_view_items)
188 |         #self.views.lst_today_meals.set_listitems(["abc","def"])
189 | 
190 |         picpercent = int(round(float(Calories.get_calories(Calories.TimeRange.DAY))/float(self.max_cals_per_day)*float(100),-1))
191 |         self.views.todaycal.src = pathhelpers.get_drawable_pathname(str(picpercent)+".png")
192 | 
193 |         totalcals = int(round(float(Calories.get_calories(Calories.TimeRange.WEEK))/float(self.max_cals_per_day*7)*float(100),-1))
194 |         self.views.weekcal.src = pathhelpers.get_drawable_pathname(str(totalcals)+".png")
195 | 
196 | 
197 | if __name__ == '__main__':
198 |     FullScreenWrapper2App.initialize(droid)
199 |     FullScreenWrapper2App.show_layout(MainScreen())
200 |     FullScreenWrapper2App.eventloop()
201 | 


--------------------------------------------------------------------------------
/res/layout/addmealscreen.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <LinearLayout
  3 | 	android:layout_width="fill_parent"
  4 | 	android:layout_height="fill_parent"
  5 | 	android:background="#ff314859"
  6 | 	android:orientation="vertical"
  7 | 	xmlns:android="http://schemas.android.com/apk/res/android">
  8 | 	<TextView
  9 | 		android:layout_width="fill_parent"
 10 | 		android:layout_height="wrap_content"
 11 | 		android:textSize="14dp"
 12 | 		android:text="Add a Meal"
 13 | 		android:textColor="#ffffffff"
 14 | 		android:gravity="center"
 15 | 		android:layout_weight="15"
 16 | 	/>
 17 | 	<LinearLayout
 18 | 		android:layout_width="fill_parent"
 19 | 		android:layout_height="wrap_content"
 20 | 		android:orientation="horizontal"
 21 | 		android:layout_weight = "8">
 22 | 		<TextView
 23 | 			android:layout_width = "fill_parent"
 24 | 			android:layout_height="fill_parent"
 25 | 			android:text = "Date"
 26 | 			android:textColor="#ffffff00"
 27 | 			android:textSize="6dp"
 28 | 			android:layout_weight="1"
 29 | 			android:gravity="center"
 30 | 			android:textStyle="1"
 31 | 		/>
 32 | 		<TextView
 33 | 			android:id="@+id/add_meal_txt_date"
 34 | 			android:layout_width = "fill_parent"
 35 | 			android:layout_height="fill_parent"
 36 | 			android:text = ""
 37 | 			android:textColor="#ffffffff" 
 38 | 			android:textSize="6dp"
 39 | 			android:layout_weight="1"
 40 | 			android:gravity="left|center_vertical"
 41 | 		/>
 42 | 		<Button
 43 | 			android:id = "@+id/but_datechange"
 44 | 			android:layout_width = "fill_parent"
 45 | 			android:layout_height="fill_parent"
 46 | 			android:textColor="#ffffffff" 
 47 | 			android:textSize="6dp"
 48 | 			android:layout_weight="1"
 49 | 			android:background="#ff66a3d2"
 50 | 			android:text = "Change" 
 51 | 			android:gravity="center"
 52 | 		/>
 53 | 	</LinearLayout>	
 54 | 	<LinearLayout
 55 | 		android:layout_width = "fill_parent"
 56 | 		android:layout_height = "wrap_content" 
 57 | 		android:layout_weight="1"    />
 58 | 	<LinearLayout
 59 | 		android:layout_width="fill_parent"
 60 | 		android:layout_height="wrap_content"
 61 | 		android:orientation="horizontal"
 62 | 		android:layout_weight="8">
 63 | 		<TextView
 64 | 			android:layout_width = "fill_parent"
 65 | 			android:layout_height="fill_parent"
 66 | 			android:text = "Time"
 67 | 			android:textColor="#ffffff00" 
 68 | 			android:textSize="6dp"
 69 | 			android:layout_weight="1"
 70 | 			android:gravity="center"
 71 | 			android:textStyle="1"
 72 | 		/>
 73 | 		<TextView
 74 | 			android:id="@+id/add_meal_txt_time"
 75 | 			android:layout_width = "fill_parent"
 76 | 			android:layout_height="fill_parent"
 77 | 			android:text = ""
 78 | 			android:textColor="#ffffffff" 
 79 | 			android:textSize="6dp"
 80 | 			android:layout_weight="1"
 81 | 			android:gravity="left|center_vertical"
 82 | 		/>
 83 | 		<Button
 84 | 			android:id = "@+id/but_timechange"
 85 | 			android:layout_width = "fill_parent"
 86 | 			android:layout_height="fill_parent"
 87 | 			android:textColor="#ffffffff" 
 88 | 			android:textSize="6dp"
 89 | 			android:layout_weight="1"
 90 | 			android:background="#ff66a3d2"
 91 | 			android:text = "Change" 
 92 | 			android:gravity="center"
 93 | 		/>
 94 | 	</LinearLayout>
 95 | 	<LinearLayout
 96 | 		android:layout_width = "fill_parent"
 97 | 		android:layout_height = "wrap_content" 
 98 | 		android:layout_weight = "1"/>
 99 | 	<LinearLayout
100 | 		android:layout_width="fill_parent"
101 | 		android:layout_height="wrap_content"
102 | 		android:orientation="horizontal"
103 | 		android:layout_weight="8">	
104 | 		<TextView
105 | 			android:layout_width = "fill_parent"
106 | 			android:layout_height="fill_parent"
107 | 			android:text = "Food-item"
108 | 			android:textColor="#ffffff00" 
109 | 			android:textSize="6dp"
110 | 			android:layout_weight="1"
111 | 			android:gravity="center"
112 | 			android:textStyle="1"
113 | 		/>
114 | 		<EditText
115 | 			android:id="@+id/add_meal_txt_fooditem"
116 | 			android:layout_width = "fill_parent"
117 | 			android:layout_height="fill_parent"
118 | 			android:text = ""
119 | 			android:textSize="6dp"
120 | 			android:textColor="#ffffff00"
121 | 			android:layout_weight="1"
122 | 			android:gravity="left|center_vertical"
123 | 		/>
124 | 		<Button
125 | 			android:id = "@+id/but_lookup"
126 | 			android:layout_width = "fill_parent"
127 | 			android:layout_height="fill_parent"
128 | 			android:textColor="#ffffff00" 
129 | 			android:textSize="6dp"
130 | 			android:layout_weight="1"
131 | 			android:background="#ff66a3d2"
132 | 			android:text = "Lookup" 
133 | 			android:gravity="center"
134 | 		/>
135 | 	</LinearLayout>	
136 | 	<LinearLayout
137 | 		android:layout_width = "fill_parent"
138 | 		android:layout_height = "wrap_content" 
139 | 		android:layout_weight = "1"/>
140 | 	<LinearLayout
141 | 		android:layout_width="fill_parent"
142 | 		android:layout_height="wrap_content"
143 | 		android:orientation="horizontal"
144 | 		android:layout_weight="8">	
145 | 		<TextView
146 | 			android:layout_width = "fill_parent"
147 | 			android:layout_height="fill_parent"
148 | 			android:text = "Calories"
149 | 			android:textColor="#ffffff00" 
150 | 			android:textSize="6dp"
151 | 			android:layout_weight="1"
152 | 			android:gravity="center"
153 | 			android:textStyle="1"
154 | 		/>
155 | 		<EditText
156 | 			android:id="@+id/add_meal_txt_calories"
157 | 			android:layout_width = "fill_parent"
158 | 			android:layout_height="fill_parent"
159 | 			android:text = ""
160 | 			android:digits="0123456789"
161 | 			android:textSize="6dp"
162 | 			android:layout_weight="1"
163 | 			android:gravity="left|center_vertical"
164 | 		/>
165 | 		<Button
166 | 			android:id = "@+id/but_save"
167 | 			android:layout_width = "fill_parent"
168 | 			android:layout_height="fill_parent"
169 | 			android:textColor="#ffffff00" 
170 | 			android:textSize="6dp"
171 | 			android:layout_weight="1"
172 | 			android:background="#ff66a3d2"
173 | 			android:text = "Save" 
174 | 			android:gravity="center"
175 | 		/>
176 | 	</LinearLayout>	
177 | 	<TextView
178 | 		android:layout_width="fill_parent"
179 | 		android:layout_height="wrap_content"
180 | 		android:textSize="10dp"
181 | 		android:text="Type calories or choose below"
182 | 		android:textColor="#ffffffff"
183 | 		android:gravity="center"
184 | 		android:layout_weight="5"
185 | 	/>
186 | 	<LinearLayout
187 | 		android:layout_width="fill_parent"
188 | 		android:layout_height="wrap_content"
189 | 		android:orientation="horizontal"
190 | 		android:layout_weight="15">
191 | 		<Button
192 | 			android:layout_width="fill_parent"
193 | 			android:layout_height="fill_parent"
194 | 			android:text="40"
195 | 			android:id="@+id/but_add_40" 
196 | 			android:textSize="8dp"
197 | 			android:background="#ff66a3d2"
198 | 			android:textColor="#ffffffff"
199 | 			android:layout_weight="1"
200 | 			android:gravity="center"/>
201 | 		<Button
202 | 			android:layout_width="fill_parent"
203 | 			android:layout_height="fill_parent"
204 | 			android:text="70"
205 | 			android:id="@+id/but_add_70" 
206 | 			android:textSize="8dp"
207 | 			android:background="#ff25567b"
208 | 			android:textColor="#ffffffff"
209 | 			android:layout_weight="1"
210 | 			android:gravity="center"/>
211 | 		<Button
212 | 			android:layout_width="fill_parent"
213 | 			android:layout_height="fill_parent"
214 | 			android:text="100"
215 | 			android:id="@+id/but_add_100" 
216 | 			android:textSize="8dp"
217 | 			android:background="#ff66a3d2"
218 | 			android:textColor="#ffffffff"
219 | 			android:layout_weight="1"
220 | 			android:gravity="center"/>
221 | 		<Button
222 | 			android:layout_width="fill_parent"
223 | 			android:layout_height="fill_parent"
224 | 			android:text="120"
225 | 			android:id="@+id/but_add_120" 
226 | 			android:textSize="8dp"
227 | 			android:background="#ff25567b"
228 | 			android:textColor="#ffffffff"
229 | 			android:layout_weight="1"
230 | 			android:gravity="center"/>
231 | 	</LinearLayout>
232 | 	<LinearLayout
233 | 		android:layout_width="fill_parent"
234 | 		android:layout_height="wrap_content"
235 | 		android:orientation="horizontal"
236 | 		android:layout_weight="15">
237 | 		<Button
238 | 			android:layout_width="fill_parent"
239 | 			android:layout_height="fill_parent"
240 | 			android:text="150"
241 | 			android:id="@+id/but_add_150" 
242 | 			android:textSize="8dp"
243 | 			android:background="#ff25567b"
244 | 			android:textColor="#ffffffff"
245 | 			android:layout_weight="1"
246 | 			android:gravity="center"/>
247 | 		<Button
248 | 			android:layout_width="fill_parent"
249 | 			android:layout_height="fill_parent"
250 | 			android:text="180"
251 | 			android:id="@+id/but_add_180" 
252 | 			android:textSize="8dp"
253 | 			android:background="#ff66a3d2"
254 | 			android:textColor="#ffffffff"
255 | 			android:layout_weight="1"
256 | 			android:gravity="center"/>
257 | 		<Button
258 | 			android:layout_width="fill_parent"
259 | 			android:layout_height="fill_parent"
260 | 			android:text="200"
261 | 			android:id="@+id/but_add_200" 
262 | 			android:textSize="8dp"
263 | 			android:background="#ff25567b"
264 | 			android:textColor="#ffffffff"
265 | 			android:layout_weight="1"
266 | 			android:gravity="center"/>
267 | 		<Button
268 | 			android:layout_width="fill_parent"
269 | 			android:layout_height="fill_parent"
270 | 			android:text="250"
271 | 			android:id="@+id/but_add_250" 
272 | 			android:textSize="8dp"
273 | 			android:background="#ff66a3d2"
274 | 			android:textColor="#ffffffff"
275 | 			android:layout_weight="1"
276 | 			android:gravity="center"/>
277 | 	</LinearLayout>
278 | 		<LinearLayout
279 | 		android:layout_width="fill_parent"
280 | 		android:layout_height="wrap_content"
281 | 		android:orientation="horizontal"
282 | 		android:layout_weight="15">
283 | 		<Button
284 | 			android:layout_width="fill_parent"
285 | 			android:layout_height="fill_parent"
286 | 			android:text="300"
287 | 			android:id="@+id/but_add_300" 
288 | 			android:textSize="8dp"
289 | 			android:background="#ff66a3d2"
290 | 			android:textColor="#ffffffff"
291 | 			android:layout_weight="1"
292 | 			android:gravity="center"/>
293 | 		<Button
294 | 			android:layout_width="fill_parent"
295 | 			android:layout_height="fill_parent"
296 | 			android:text="350"
297 | 			android:id="@+id/but_add_350" 
298 | 			android:textSize="8dp"
299 | 			android:background="#ff25567b"
300 | 			android:textColor="#ffffffff"
301 | 			android:layout_weight="1"
302 | 			android:gravity="center"/>
303 | 		<Button
304 | 			android:layout_width="fill_parent"
305 | 			android:layout_height="fill_parent"
306 | 			android:text="400"
307 | 			android:id="@+id/but_add_400" 
308 | 			android:textSize="8dp"
309 | 			android:background="#ff66a3d2"
310 | 			android:textColor="#ffffffff"
311 | 			android:layout_weight="1"
312 | 			android:gravity="center"/>
313 | 		<Button
314 | 			android:layout_width="fill_parent"
315 | 			android:layout_height="fill_parent"
316 | 			android:text="450"
317 | 			android:id="@+id/but_add_450" 
318 | 			android:textSize="8dp"
319 | 			android:background="#ff25567b"
320 | 			android:textColor="#ffffffff"
321 | 			android:layout_weight="1"
322 | 			android:gravity="center"/>
323 | 	</LinearLayout>
324 | </LinearLayout>	
325 | 


--------------------------------------------------------------------------------
/utils/peewee.py:
--------------------------------------------------------------------------------
   1 | #     (\
   2 | #     (  \  /(o)\     caw!
   3 | #     (   \/  ()/ /)
   4 | #      (   `;.))'".)
   5 | #       `(/////.-'
   6 | #    =====))=))===()
   7 | #      ///'
   8 | #     //
   9 | #    '
  10 | from __future__ import with_statement
  11 | import datetime
  12 | import copy
  13 | import decimal
  14 | import logging
  15 | import os
  16 | import re
  17 | import threading
  18 | import time
  19 | import warnings
  20 | 
  21 | try:
  22 |     import sqlite3
  23 | except ImportError:
  24 |     sqlite3 = None
  25 | 
  26 | try:
  27 |     import psycopg2
  28 | except ImportError:
  29 |     psycopg2 = None
  30 | 
  31 | try:
  32 |     import MySQLdb as mysql
  33 | except ImportError:
  34 |     mysql = None
  35 | 
  36 | __all__ = [
  37 |     'ImproperlyConfigured', 'SqliteDatabase', 'MySQLDatabase', 'PostgresqlDatabase',
  38 |     'asc', 'desc', 'Count', 'Max', 'Min', 'Sum', 'Q', 'Field', 'CharField', 'TextField',
  39 |     'DateTimeField', 'BooleanField', 'DecimalField', 'FloatField', 'IntegerField',
  40 |     'PrimaryKeyField', 'ForeignKeyField', 'DoubleField', 'BigIntegerField', 'Model',
  41 |     'filter_query', 'annotate_query', 'F', 'R', 'DateField', 'TimeField',
  42 |     'transaction',
  43 | ]
  44 | 
  45 | class ImproperlyConfigured(Exception):
  46 |     pass
  47 | 
  48 | if sqlite3 is None and psycopg2 is None and mysql is None:
  49 |     raise ImproperlyConfigured('Either sqlite3, psycopg2 or MySQLdb must be installed')
  50 | 
  51 | if sqlite3:
  52 |     sqlite3.register_adapter(decimal.Decimal, str)
  53 |     sqlite3.register_adapter(datetime.date, str)
  54 |     sqlite3.register_adapter(datetime.time, str)
  55 |     sqlite3.register_converter('decimal', lambda v: decimal.Decimal(v))
  56 | 
  57 | if psycopg2:
  58 |     import psycopg2.extensions
  59 |     psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
  60 |     psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY)
  61 | 
  62 | 
  63 | DATABASE_NAME = os.environ.get('PEEWEE_DATABASE', 'peewee.db')
  64 | logger = logging.getLogger('peewee.logger')
  65 | 
  66 | 
  67 | class BaseAdapter(object):
  68 |     """
  69 |     The various subclasses of `BaseAdapter` provide a bridge between the high-
  70 |     level `Database` abstraction and the underlying python libraries like
  71 |     psycopg2.  It also provides a way to unify the pythonic field types with
  72 |     the underlying column types used by the database engine.
  73 | 
  74 |     The `BaseAdapter` provides two types of mappings:
  75 |     - mapping between filter operations and their database equivalents
  76 |     - mapping between basic field types and their database column types
  77 | 
  78 |     The `BaseAdapter` also is the mechanism used by the `Database` class to:
  79 |     - handle connections with the database
  80 |     - extract information from the database cursor
  81 |     """
  82 |     operations = {'eq': '= %s'}
  83 |     interpolation = '%s'
  84 |     sequence_support = False
  85 |     for_update_support = False
  86 |     subquery_delete_same_table = True
  87 |     reserved_tables = []
  88 |     quote_char = '"'
  89 | 
  90 |     def get_field_types(self):
  91 |         field_types = {
  92 |             'integer': 'INTEGER',
  93 |             'bigint': 'INTEGER',
  94 |             'float': 'REAL',
  95 |             'decimal': 'DECIMAL',
  96 |             'double': 'REAL',
  97 |             'string': 'VARCHAR',
  98 |             'text': 'TEXT',
  99 |             'datetime': 'DATETIME',
 100 |             'time': 'TIME',
 101 |             'date': 'DATE',
 102 |             'primary_key': 'INTEGER',
 103 |             'primary_key_with_sequence': 'INTEGER',
 104 |             'foreign_key': 'INTEGER',
 105 |             'boolean': 'SMALLINT',
 106 |             'blob': 'BLOB',
 107 |         }
 108 |         field_types.update(self.get_field_overrides())
 109 |         return field_types
 110 | 
 111 |     def get_field_overrides(self):
 112 |         return {}
 113 | 
 114 |     def connect(self, database, **kwargs):
 115 |         raise NotImplementedError
 116 | 
 117 |     def close(self, conn):
 118 |         conn.close()
 119 | 
 120 |     def lookup_cast(self, lookup, value):
 121 |         """
 122 |         When a lookup is being performed as a part of a WHERE clause, provides
 123 |         a way to alter the incoming value that is passed to the database driver
 124 |         as part of the list of parameters
 125 |         """
 126 |         if lookup in ('contains', 'icontains'):
 127 |             return '%%%s%%' % value
 128 |         elif lookup in ('startswith', 'istartswith'):
 129 |             return '%s%%' % value
 130 |         return value
 131 | 
 132 |     def last_insert_id(self, cursor, model):
 133 |         return cursor.lastrowid
 134 | 
 135 |     def rows_affected(self, cursor):
 136 |         return cursor.rowcount
 137 | 
 138 | 
 139 | class SqliteAdapter(BaseAdapter):
 140 |     # note the sqlite library uses a non-standard interpolation string
 141 |     operations = {
 142 |         'lt': '< %s',
 143 |         'lte': '<= %s',
 144 |         'gt': '> %s',
 145 |         'gte': '>= %s',
 146 |         'eq': '= %s',
 147 |         'ne': '!= %s', # watch yourself with this one
 148 |         'in': 'IN (%s)', # special-case to list q-marks
 149 |         'is': 'IS %s',
 150 |         'isnull': 'IS NULL',
 151 |         'between': 'BETWEEN %s AND %s',
 152 |         'icontains': "LIKE %s ESCAPE '\\'", # surround param with %'s
 153 |         'contains': "GLOB %s", # surround param with *'s
 154 |         'istartswith': "LIKE %s ESCAPE '\\'",
 155 |         'startswith': "GLOB %s",
 156 |     }
 157 |     interpolation = '?'
 158 | 
 159 |     def connect(self, database, **kwargs):
 160 |         if not sqlite3:
 161 |             raise ImproperlyConfigured('sqlite3 must be installed on the system')
 162 |         return sqlite3.connect(database, **kwargs)
 163 | 
 164 |     def lookup_cast(self, lookup, value):
 165 |         if lookup == 'contains':
 166 |             return '*%s*' % value
 167 |         elif lookup == 'icontains':
 168 |             return '%%%s%%' % value
 169 |         elif lookup == 'startswith':
 170 |             return '%s*' % value
 171 |         elif lookup == 'istartswith':
 172 |             return '%s%%' % value
 173 |         return value
 174 | 
 175 | 
 176 | class PostgresqlAdapter(BaseAdapter):
 177 |     operations = {
 178 |         'lt': '< %s',
 179 |         'lte': '<= %s',
 180 |         'gt': '> %s',
 181 |         'gte': '>= %s',
 182 |         'eq': '= %s',
 183 |         'ne': '!= %s', # watch yourself with this one
 184 |         'in': 'IN (%s)', # special-case to list q-marks
 185 |         'is': 'IS %s',
 186 |         'isnull': 'IS NULL',
 187 |         'between': 'BETWEEN %s AND %s',
 188 |         'icontains': 'ILIKE %s', # surround param with %'s
 189 |         'contains': 'LIKE %s', # surround param with *'s
 190 |         'istartswith': 'ILIKE %s',
 191 |         'startswith': 'LIKE %s',
 192 |     }
 193 |     reserved_tables = ['user']
 194 |     sequence_support = True
 195 |     for_update_support = True
 196 | 
 197 |     def connect(self, database, **kwargs):
 198 |         if not psycopg2:
 199 |             raise ImproperlyConfigured('psycopg2 must be installed on the system')
 200 |         return psycopg2.connect(database=database, **kwargs)
 201 | 
 202 |     def get_field_overrides(self):
 203 |         return {
 204 |             'primary_key': 'SERIAL',
 205 |             'primary_key_with_sequence': 'INTEGER',
 206 |             'datetime': 'TIMESTAMP',
 207 |             'decimal': 'NUMERIC',
 208 |             'double': 'DOUBLE PRECISION',
 209 |             'bigint': 'BIGINT',
 210 |             'boolean': 'BOOLEAN',
 211 |             'blob': 'BYTEA',
 212 |         }
 213 | 
 214 |     def last_insert_id(self, cursor, model):
 215 |         if model._meta.pk_sequence:
 216 |             cursor.execute("SELECT CURRVAL('\"%s\"')" % (
 217 |                 model._meta.pk_sequence))
 218 |         else:
 219 |             cursor.execute("SELECT CURRVAL('\"%s_%s_seq\"')" % (
 220 |                 model._meta.db_table, model._meta.pk_col))
 221 |         return cursor.fetchone()[0]
 222 | 
 223 | 
 224 | class MySQLAdapter(BaseAdapter):
 225 |     operations = {
 226 |         'lt': '< %s',
 227 |         'lte': '<= %s',
 228 |         'gt': '> %s',
 229 |         'gte': '>= %s',
 230 |         'eq': '= %s',
 231 |         'ne': '!= %s', # watch yourself with this one
 232 |         'in': 'IN (%s)', # special-case to list q-marks
 233 |         'is': 'IS %s',
 234 |         'isnull': 'IS NULL',
 235 |         'between': 'BETWEEN %s AND %s',
 236 |         'icontains': 'LIKE %s', # surround param with %'s
 237 |         'contains': 'LIKE BINARY %s', # surround param with *'s
 238 |         'istartswith': 'LIKE %s',
 239 |         'startswith': 'LIKE BINARY %s',
 240 |     }
 241 |     quote_char = '`'
 242 |     for_update_support = True
 243 |     subquery_delete_same_table = False
 244 | 
 245 |     def connect(self, database, **kwargs):
 246 |         if not mysql:
 247 |             raise ImproperlyConfigured('MySQLdb must be installed on the system')
 248 |         conn_kwargs = {
 249 |             'charset': 'utf8',
 250 |             'use_unicode': True,
 251 |         }
 252 |         conn_kwargs.update(kwargs)
 253 |         return mysql.connect(db=database, **conn_kwargs)
 254 | 
 255 |     def get_field_overrides(self):
 256 |         return {
 257 |             'primary_key': 'integer AUTO_INCREMENT',
 258 |             'boolean': 'bool',
 259 |             'float': 'float',
 260 |             'double': 'double precision',
 261 |             'bigint': 'bigint',
 262 |             'text': 'longtext',
 263 |             'decimal': 'numeric',
 264 |         }
 265 | 
 266 | 
 267 | class Database(object):
 268 |     """
 269 |     A high-level api for working with the supported database engines.  `Database`
 270 |     provides a wrapper around some of the functions performed by the `Adapter`,
 271 |     in addition providing support for:
 272 |     - execution of SQL queries
 273 |     - creating and dropping tables and indexes
 274 |     """
 275 |     def require_sequence_support(func):
 276 |         def inner(self, *args, **kwargs):
 277 |             if not self.adapter.sequence_support:
 278 |                 raise ValueError('%s adapter does not support sequences' % (self.adapter))
 279 |             return func(self, *args, **kwargs)
 280 |         return inner
 281 | 
 282 |     def __init__(self, adapter, database, threadlocals=False, autocommit=True, **connect_kwargs):
 283 |         self.adapter = adapter
 284 |         self.init(database, **connect_kwargs)
 285 | 
 286 |         if threadlocals:
 287 |             self.__local = threading.local()
 288 |         else:
 289 |             self.__local = type('DummyLocal', (object,), {})
 290 | 
 291 |         self._conn_lock = threading.Lock()
 292 |         self.autocommit = autocommit
 293 | 
 294 |     def init(self, database, **connect_kwargs):
 295 |         self.deferred = database is None
 296 |         self.database = database
 297 |         self.connect_kwargs = connect_kwargs
 298 | 
 299 |     def connect(self):
 300 |         with self._conn_lock:
 301 |             if self.deferred:
 302 |                 raise Exception('Error, database not properly initialized before opening connection')
 303 |             self.__local.conn = self.adapter.connect(self.database, **self.connect_kwargs)
 304 |             self.__local.closed = False
 305 | 
 306 |     def close(self):
 307 |         with self._conn_lock:
 308 |             if self.deferred:
 309 |                 raise Exception('Error, database not properly initialized before closing connection')
 310 |             self.adapter.close(self.__local.conn)
 311 |             self.__local.closed = True
 312 | 
 313 |     def get_conn(self):
 314 |         if not hasattr(self.__local, 'closed') or self.__local.closed:
 315 |             self.connect()
 316 |         return self.__local.conn
 317 | 
 318 |     def get_cursor(self):
 319 |         return self.get_conn().cursor()
 320 | 
 321 |     def execute(self, sql, params=None):
 322 |         cursor = self.get_cursor()
 323 |         res = cursor.execute(sql, params or ())
 324 |         if self.get_autocommit():
 325 |             self.commit()
 326 |         logger.debug((sql, params))
 327 |         return cursor
 328 | 
 329 |     def commit(self):
 330 |         self.get_conn().commit()
 331 | 
 332 |     def rollback(self):
 333 |         self.get_conn().rollback()
 334 | 
 335 |     def set_autocommit(self, autocommit):
 336 |         self.__local.autocommit = autocommit
 337 | 
 338 |     def get_autocommit(self):
 339 |         if not hasattr(self.__local, 'autocommit'):
 340 |             self.set_autocommit(self.autocommit)
 341 |         return self.__local.autocommit
 342 | 
 343 |     def commit_on_success(self, func):
 344 |         def inner(*args, **kwargs):
 345 |             orig = self.get_autocommit()
 346 |             self.set_autocommit(False)
 347 |             try:
 348 |                 res = func(*args, **kwargs)
 349 |                 self.commit()
 350 |             except:
 351 |                 self.rollback()
 352 |                 raise
 353 |             else:
 354 |                 return res
 355 |             finally:
 356 |                 self.set_autocommit(orig)
 357 |         return inner
 358 | 
 359 |     def last_insert_id(self, cursor, model):
 360 |         if model._meta.auto_increment:
 361 |             return self.adapter.last_insert_id(cursor, model)
 362 | 
 363 |     def rows_affected(self, cursor):
 364 |         return self.adapter.rows_affected(cursor)
 365 | 
 366 |     def quote_name(self, name):
 367 |         return ''.join((self.adapter.quote_char, name, self.adapter.quote_char))
 368 | 
 369 |     def column_for_field(self, field):
 370 |         return self.column_for_field_type(field.get_db_field())
 371 | 
 372 |     def column_for_field_type(self, db_field_type):
 373 |         try:
 374 |             return self.adapter.get_field_types()[db_field_type]
 375 |         except KeyError:
 376 |             raise AttributeError('Unknown field type: "%s", valid types are: %s' % \
 377 |                 db_field_type, ', '.join(self.adapter.get_field_types().keys())
 378 |             )
 379 | 
 380 |     def field_sql(self, field):
 381 |         return '%s %s' % (self.quote_name(field.db_column), field.render_field_template())
 382 | 
 383 |     def create_table_query(self, model_class, safe, extra=''):
 384 |         if model_class._meta.pk_sequence and self.adapter.sequence_support:
 385 |             if not self.sequence_exists(model_class._meta.pk_sequence):
 386 |                 self.create_sequence(model_class._meta.pk_sequence)
 387 |         framing = safe and "CREATE TABLE IF NOT EXISTS %s (%s)%s;" or "CREATE TABLE %s (%s)%s;"
 388 |         columns = []
 389 | 
 390 |         for field in model_class._meta.get_fields():
 391 |             columns.append(self.field_sql(field))
 392 | 
 393 |         if extra:
 394 |             extra = ' ' + extra
 395 | 
 396 |         table = self.quote_name(model_class._meta.db_table)
 397 | 
 398 |         return framing % (table, ', '.join(columns), extra)
 399 | 
 400 |     def create_table(self, model_class, safe=False, extra=''):
 401 |         self.execute(self.create_table_query(model_class, safe, extra))
 402 | 
 403 |     def create_index_query(self, model_class, field_name, unique):
 404 |         framing = 'CREATE %(unique)s INDEX %(index)s ON %(table)s(%(field)s);'
 405 | 
 406 |         if field_name not in model_class._meta.fields:
 407 |             raise AttributeError(
 408 |                 'Field %s not on model %s' % (field_name, model_class)
 409 |             )
 410 | 
 411 |         field_obj = model_class._meta.fields[field_name]
 412 | 
 413 |         db_table = model_class._meta.db_table
 414 |         index_name = self.quote_name('%s_%s' % (db_table, field_obj.db_column))
 415 | 
 416 |         unique_expr = ternary(unique, 'UNIQUE', '')
 417 | 
 418 |         return framing % {
 419 |             'unique': unique_expr,
 420 |             'index': index_name,
 421 |             'table': self.quote_name(db_table),
 422 |             'field': self.quote_name(field_obj.db_column),
 423 |         }
 424 | 
 425 |     def create_index(self, model_class, field_name, unique=False):
 426 |         self.execute(self.create_index_query(model_class, field_name, unique))
 427 | 
 428 |     def create_foreign_key(self, model_class, field):
 429 |         return self.create_index(model_class, field.name, field.unique)
 430 | 
 431 |     def drop_table(self, model_class, fail_silently=False):
 432 |         framing = fail_silently and 'DROP TABLE IF EXISTS %s;' or 'DROP TABLE %s;'
 433 |         self.execute(framing % self.quote_name(model_class._meta.db_table))
 434 | 
 435 |     def add_column_sql(self, model_class, field_name):
 436 |         field = model_class._meta.fields[field_name]
 437 |         return 'ALTER TABLE %s ADD COLUMN %s' % (
 438 |             self.quote_name(model_class._meta.db_table),
 439 |             self.field_sql(field),
 440 |         )
 441 | 
 442 |     def rename_column_sql(self, model_class, field_name, new_name):
 443 |         # this assumes that the field on the model points to the *old* fieldname
 444 |         field = model_class._meta.fields[field_name]
 445 |         return 'ALTER TABLE %s RENAME COLUMN %s TO %s' % (
 446 |             self.quote_name(model_class._meta.db_table),
 447 |             self.quote_name(field.db_column),
 448 |             self.quote_name(new_name),
 449 |         )
 450 | 
 451 |     def drop_column_sql(self, model_class, field_name):
 452 |         field = model_class._meta.fields[field_name]
 453 |         return 'ALTER TABLE %s DROP COLUMN %s' % (
 454 |             self.quote_name(model_class._meta.db_table),
 455 |             self.quote_name(field.db_column),
 456 |         )
 457 | 
 458 |     @require_sequence_support
 459 |     def create_sequence(self, sequence_name):
 460 |         return self.execute('CREATE SEQUENCE %s;' % self.quote_name(sequence_name))
 461 | 
 462 |     @require_sequence_support
 463 |     def drop_sequence(self, sequence_name):
 464 |         return self.execute('DROP SEQUENCE %s;' % self.quote_name(sequence_name))
 465 | 
 466 |     def get_indexes_for_table(self, table):
 467 |         raise NotImplementedError
 468 | 
 469 |     def get_tables(self):
 470 |         raise NotImplementedError
 471 | 
 472 |     def sequence_exists(self, sequence):
 473 |         raise NotImplementedError
 474 | 
 475 |     def transaction(self):
 476 |         return transaction(self)
 477 | 
 478 | 
 479 | class SqliteDatabase(Database):
 480 |     def __init__(self, database, **connect_kwargs):
 481 |         super(SqliteDatabase, self).__init__(SqliteAdapter(), database, **connect_kwargs)
 482 | 
 483 |     def get_indexes_for_table(self, table):
 484 |         res = self.execute('PRAGMA index_list(%s);' % self.quote_name(table))
 485 |         rows = sorted([(r[1], r[2] == 1) for r in res.fetchall()])
 486 |         return rows
 487 | 
 488 |     def get_tables(self):
 489 |         res = self.execute('select name from sqlite_master where type="table" order by name')
 490 |         return [r[0] for r in res.fetchall()]
 491 | 
 492 |     def drop_column_sql(self, model_class, field_name):
 493 |         raise NotImplementedError('Sqlite3 does not have direct support for dropping columns')
 494 | 
 495 |     def rename_column_sql(self, model_class, field_name, new_name):
 496 |         raise NotImplementedError('Sqlite3 does not have direct support for renaming columns')
 497 | 
 498 | 
 499 | class PostgresqlDatabase(Database):
 500 |     def __init__(self, database, **connect_kwargs):
 501 |         super(PostgresqlDatabase, self).__init__(PostgresqlAdapter(), database, **connect_kwargs)
 502 | 
 503 |     def get_indexes_for_table(self, table):
 504 |         res = self.execute("""
 505 |             SELECT c2.relname, i.indisprimary, i.indisunique
 506 |             FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i
 507 |             WHERE c.relname = %s AND c.oid = i.indrelid AND i.indexrelid = c2.oid
 508 |             ORDER BY i.indisprimary DESC, i.indisunique DESC, c2.relname""", (table,))
 509 |         return sorted([(r[0], r[1]) for r in res.fetchall()])
 510 | 
 511 |     def get_tables(self):
 512 |         res = self.execute("""
 513 |             SELECT c.relname
 514 |             FROM pg_catalog.pg_class c
 515 |             LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
 516 |             WHERE c.relkind IN ('r', 'v', '')
 517 |                 AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
 518 |                 AND pg_catalog.pg_table_is_visible(c.oid)
 519 |             ORDER BY c.relname""")
 520 |         return [row[0] for row in res.fetchall()]
 521 | 
 522 |     def sequence_exists(self, sequence):
 523 |         res = self.execute("""
 524 |             SELECT COUNT(*)
 525 |             FROM pg_class, pg_namespace
 526 |             WHERE relkind='S'
 527 |                 AND pg_class.relnamespace = pg_namespace.oid
 528 |                 AND relname=%s""", (sequence,))
 529 |         return bool(res.fetchone()[0])
 530 | 
 531 |     def set_search_path(self, *search_path):
 532 |         path_params = ','.join(['%s'] * len(search_path))
 533 |         self.execute('SET search_path TO %s' % path_params, search_path)
 534 | 
 535 | 
 536 | class MySQLDatabase(Database):
 537 |     def __init__(self, database, **connect_kwargs):
 538 |         super(MySQLDatabase, self).__init__(MySQLAdapter(), database, **connect_kwargs)
 539 | 
 540 |     def create_foreign_key(self, model_class, field):
 541 |         framing = """
 542 |             ALTER TABLE %(table)s ADD CONSTRAINT %(constraint)s
 543 |             FOREIGN KEY (%(field)s) REFERENCES %(to)s(%(to_field)s)%(cascade)s;
 544 |         """
 545 |         db_table = model_class._meta.db_table
 546 |         constraint = 'fk_%s_%s_%s' % (
 547 |             db_table,
 548 |             field.to._meta.db_table,
 549 |             field.db_column,
 550 |         )
 551 | 
 552 |         query = framing % {
 553 |             'table': self.quote_name(db_table),
 554 |             'constraint': self.quote_name(constraint),
 555 |             'field': self.quote_name(field.db_column),
 556 |             'to': self.quote_name(field.to._meta.db_table),
 557 |             'to_field': self.quote_name(field.to._meta.pk_col),
 558 |             'cascade': ' ON DELETE CASCADE' if field.cascade else '',
 559 |         }
 560 | 
 561 |         self.execute(query)
 562 |         return super(MySQLDatabase, self).create_foreign_key(model_class, field)
 563 | 
 564 |     def rename_column_sql(self, model_class, field_name, new_name):
 565 |         field = model_class._meta.fields[field_name]
 566 |         return 'ALTER TABLE %s CHANGE COLUMN %s %s %s' % (
 567 |             self.quote_name(model_class._meta.db_table),
 568 |             self.quote_name(field.db_column),
 569 |             self.quote_name(new_name),
 570 |             field.render_field_template(),
 571 |         )
 572 | 
 573 |     def get_indexes_for_table(self, table):
 574 |         res = self.execute('SHOW INDEXES IN %s;' % self.quote_name(table))
 575 |         rows = sorted([(r[2], r[1] == 0) for r in res.fetchall()])
 576 |         return rows
 577 | 
 578 |     def get_tables(self):
 579 |         res = self.execute('SHOW TABLES;')
 580 |         return [r[0] for r in res.fetchall()]
 581 | 
 582 | 
 583 | class transaction(object):
 584 |     def __init__(self, db):
 585 |         self.db = db
 586 | 
 587 |     def __enter__(self):
 588 |         self._orig = self.db.get_autocommit()
 589 |         self.db.set_autocommit(False)
 590 | 
 591 |     def __exit__(self, exc_type, exc_val, exc_tb):
 592 |         if exc_type:
 593 |             self.db.rollback()
 594 |         else:
 595 |             self.db.commit()
 596 |         self.db.set_autocommit(self._orig)
 597 | 
 598 | 
 599 | class QueryResultWrapper(object):
 600 |     """
 601 |     Provides an iterator over the results of a raw Query, additionally doing
 602 |     two things:
 603 |     - converts rows from the database into model instances
 604 |     - ensures that multiple iterations do not result in multiple queries
 605 |     """
 606 |     def __init__(self, model, cursor, meta=None):
 607 |         self.model = model
 608 |         self.cursor = cursor
 609 |         self.query_meta = meta or {}
 610 |         self.column_meta = self.query_meta.get('columns')
 611 |         self.join_meta = self.query_meta.get('graph')
 612 | 
 613 |         self.__ct = 0
 614 |         self.__idx = 0
 615 | 
 616 |         self._result_cache = []
 617 |         self._populated = False
 618 | 
 619 |     def model_from_rowset(self, model_class, attr_dict):
 620 |         instance = model_class()
 621 |         for attr, value in attr_dict.iteritems():
 622 |             if attr in instance._meta.columns:
 623 |                 field = instance._meta.columns[attr]
 624 |                 setattr(instance, field.name, field.python_value(value))
 625 |             else:
 626 |                 setattr(instance, attr, value)
 627 |         return instance
 628 | 
 629 |     def _row_to_dict(self, row):
 630 |         return dict((self.cursor.description[i][0], value)
 631 |             for i, value in enumerate(row))
 632 | 
 633 |     def construct_instance(self, row):
 634 |         if not self.column_meta:
 635 |             # use attribute names pulled from the result cursor description,
 636 |             # and do not attempt to follow joined models
 637 |             row_dict = self._row_to_dict(row)
 638 |             return self.model_from_rowset(self.model, row_dict)
 639 |         else:
 640 |             # we have columns, models, and a graph of joins to reconstruct
 641 |             collected_models = {}
 642 |             for i, (model, col) in enumerate(self.column_meta):
 643 |                 value = row[i]
 644 | 
 645 |                 if isinstance(col, tuple):
 646 |                     if len(col) == 3:
 647 |                         model = self.model # special-case aggregates
 648 |                         col_name = attr = col[2]
 649 |                     else:
 650 |                         col_name, attr = col
 651 |                 else:
 652 |                     col_name = attr = col
 653 | 
 654 |                 if model not in collected_models:
 655 |                     collected_models[model] = model()
 656 | 
 657 |                 instance = collected_models[model]
 658 | 
 659 |                 if col_name in instance._meta.columns:
 660 |                     field = instance._meta.columns[col_name]
 661 |                     setattr(instance, field.name, field.python_value(value))
 662 |                 else:
 663 |                     setattr(instance, attr, value)
 664 | 
 665 |             return self.follow_joins(self.join_meta, collected_models, self.model)
 666 | 
 667 |     def follow_joins(self, joins, collected_models, current):
 668 |         inst = collected_models[current]
 669 | 
 670 |         if current not in joins:
 671 |             return inst
 672 | 
 673 |         for joined_model, _, _ in joins[current]:
 674 |             if joined_model in collected_models:
 675 |                 joined_inst = self.follow_joins(joins, collected_models, joined_model)
 676 |                 fk_field = current._meta.get_related_field_for_model(joined_model)
 677 | 
 678 |                 if not fk_field:
 679 |                     continue
 680 | 
 681 |                 if not joined_inst.get_pk():
 682 |                     joined_inst.set_pk(getattr(inst, fk_field.id_storage))
 683 | 
 684 |                 setattr(inst, fk_field.name, joined_inst)
 685 |                 setattr(inst, fk_field.id_storage, joined_inst.get_pk())
 686 | 
 687 |         return inst
 688 | 
 689 |     def __iter__(self):
 690 |         self.__idx = 0
 691 | 
 692 |         if not self._populated:
 693 |             return self
 694 |         else:
 695 |             return iter(self._result_cache)
 696 | 
 697 |     def first(self):
 698 |         try:
 699 |             self.__idx = 0 # move to beginning of the list
 700 |             inst = self.next()
 701 |         except StopIteration:
 702 |             inst = None
 703 | 
 704 |         self.__idx = 0
 705 |         return inst
 706 | 
 707 |     def fill_cache(self):
 708 |         if not self._populated:
 709 |             idx = self.__idx
 710 |             self.__idx = self.__ct
 711 |             for x in self:
 712 |                 pass
 713 |             self.__idx = idx
 714 | 
 715 |     def iterate(self):
 716 |         row = self.cursor.fetchone()
 717 |         if row:
 718 |             return self.construct_instance(row)
 719 |         else:
 720 |             self._populated = True
 721 |             raise StopIteration
 722 | 
 723 |     def iterator(self):
 724 |         while 1:
 725 |             yield self.iterate()
 726 | 
 727 |     def next(self):
 728 |         if self.__idx < self.__ct:
 729 |             inst = self._result_cache[self.__idx]
 730 |             self.__idx += 1
 731 |             return inst
 732 | 
 733 |         instance = self.iterate()
 734 |         instance.prepared() # <-- model prepared hook
 735 |         self._result_cache.append(instance)
 736 |         self.__ct += 1
 737 |         self.__idx += 1
 738 |         return instance
 739 | 
 740 | 
 741 | # create
 742 | class DoesNotExist(Exception):
 743 |     pass
 744 | 
 745 | 
 746 | # semantic wrappers for ordering the results of a `SelectQuery`
 747 | def asc(f):
 748 |     return (f, 'ASC')
 749 | 
 750 | def desc(f):
 751 |     return (f, 'DESC')
 752 | 
 753 | # wrappers for performing aggregation in a `SelectQuery`
 754 | def Count(f, alias='count'):
 755 |     return ('COUNT', f, alias)
 756 | 
 757 | def Max(f, alias='max'):
 758 |     return ('MAX', f, alias)
 759 | 
 760 | def Min(f, alias='min'):
 761 |     return ('MIN', f, alias)
 762 | 
 763 | def Sum(f, alias='sum'):
 764 |     return ('SUM', f, alias)
 765 | 
 766 | # decorator for query methods to indicate that they change the state of the
 767 | # underlying data structures
 768 | def returns_clone(func):
 769 |     def inner(self, *args, **kwargs):
 770 |         clone = self.clone()
 771 |         res = func(clone, *args, **kwargs)
 772 |         return clone
 773 |     return inner
 774 | 
 775 | # helpers
 776 | ternary = lambda cond, t, f: (cond and [t] or [f])[0]
 777 | 
 778 | 
 779 | class Node(object):
 780 |     def __init__(self, connector='AND', children=None):
 781 |         self.connector = connector
 782 |         self.children = children or []
 783 |         self.negated = False
 784 | 
 785 |     def connect(self, rhs, connector):
 786 |         if isinstance(rhs, Leaf):
 787 |             if connector == self.connector:
 788 |                 self.children.append(rhs)
 789 |                 return self
 790 |             else:
 791 |                 p = Node(connector)
 792 |                 p.children = [self, rhs]
 793 |                 return p
 794 |         elif isinstance(rhs, Node):
 795 |             p = Node(connector)
 796 |             p.children = [self, rhs]
 797 |             return p
 798 | 
 799 |     def __or__(self, rhs):
 800 |         return self.connect(rhs, 'OR')
 801 | 
 802 |     def __and__(self, rhs):
 803 |         return self.connect(rhs, 'AND')
 804 | 
 805 |     def __invert__(self):
 806 |         self.negated = not self.negated
 807 |         return self
 808 | 
 809 |     def __nonzero__(self):
 810 |         return bool(self.children)
 811 | 
 812 |     def __unicode__(self):
 813 |         query = []
 814 |         nodes = []
 815 |         for child in self.children:
 816 |             if isinstance(child, Q):
 817 |                 query.append(unicode(child))
 818 |             elif isinstance(child, Node):
 819 |                 nodes.append('(%s)' % unicode(child))
 820 |         query.extend(nodes)
 821 |         connector = ' %s ' % self.connector
 822 |         query = connector.join(query)
 823 |         if self.negated:
 824 |             query = 'NOT %s' % query
 825 |         return query
 826 | 
 827 | 
 828 | class Leaf(object):
 829 |     def __init__(self):
 830 |         self.parent = None
 831 | 
 832 |     def connect(self, connector):
 833 |         if self.parent is None:
 834 |             self.parent = Node(connector)
 835 |             self.parent.children.append(self)
 836 | 
 837 |     def __or__(self, rhs):
 838 |         self.connect('OR')
 839 |         return self.parent | rhs
 840 | 
 841 |     def __and__(self, rhs):
 842 |         self.connect('AND')
 843 |         return self.parent & rhs
 844 | 
 845 |     def __invert__(self):
 846 |         self.negated = not self.negated
 847 |         return self
 848 | 
 849 | 
 850 | class Q(Leaf):
 851 |     def __init__(self, _model=None, **kwargs):
 852 |         self.model = _model
 853 |         self.query = kwargs
 854 |         self.negated = False
 855 |         super(Q, self).__init__()
 856 | 
 857 |     def __unicode__(self):
 858 |         bits = ['%s = %s' % (k, v) for k, v in self.query.items()]
 859 |         if len(self.query.items()) > 1:
 860 |             connector = ' AND '
 861 |             expr = '(%s)' % connector.join(bits)
 862 |         else:
 863 |             expr = bits[0]
 864 |         if self.negated:
 865 |             expr = 'NOT %s' % expr
 866 |         return expr
 867 | 
 868 | 
 869 | class F(object):
 870 |     def __init__(self, field, model=None):
 871 |         self.field = field
 872 |         self.model = model
 873 |         self.op = None
 874 |         self.value = None
 875 | 
 876 |     def __add__(self, rhs):
 877 |         self.op = '+'
 878 |         self.value = rhs
 879 |         return self
 880 | 
 881 |     def __sub__(self, rhs):
 882 |         self.op = '-'
 883 |         self.value = rhs
 884 |         return self
 885 | 
 886 | 
 887 | class R(Leaf):
 888 |     def __init__(self, *params):
 889 |         self.params = params
 890 |         super(R, self).__init__()
 891 | 
 892 |     def sql_select(self):
 893 |         if len(self.params) == 2:
 894 |             return self.params
 895 |         else:
 896 |             raise ValueError('Incorrect number of argument provided for R() expression')
 897 | 
 898 |     def sql_where(self):
 899 |         return self.params[0], self.params[1:]
 900 | 
 901 | 
 902 | def apply_model(model, item):
 903 |     """
 904 |     Q() objects take a model, which provides context for the keyword arguments.
 905 |     In this way Q() objects can be mixed across models.  The purpose of this
 906 |     function is to recurse into a query datastructure and apply the given model
 907 |     to all Q() objects that do not have a model explicitly set.
 908 |     """
 909 |     if isinstance(item, Node):
 910 |         for child in item.children:
 911 |             apply_model(model, child)
 912 |     elif isinstance(item, Q):
 913 |         if item.model is None:
 914 |             item.model = model
 915 | 
 916 | def parseq(model, *args, **kwargs):
 917 |     """
 918 |     Convert any query into a single Node() object -- used to build up the list
 919 |     of where clauses when querying.
 920 |     """
 921 |     node = Node()
 922 | 
 923 |     for piece in args:
 924 |         apply_model(model, piece)
 925 |         if isinstance(piece, (Q, R, Node)):
 926 |             node.children.append(piece)
 927 |         else:
 928 |             raise TypeError('Unknown object: %s', piece)
 929 | 
 930 |     if kwargs:
 931 |         node.children.append(Q(model, **kwargs))
 932 | 
 933 |     return node
 934 | 
 935 | def find_models(item):
 936 |     """
 937 |     Utility function to find models referenced in a query and return a set()
 938 |     containing them.  This function is used to generate the list of models that
 939 |     are part of a where clause.
 940 |     """
 941 |     seen = set()
 942 |     if isinstance(item, Node):
 943 |         for child in item.children:
 944 |             seen.update(find_models(child))
 945 |     elif isinstance(item, Q):
 946 |         seen.add(item.model)
 947 |     return seen
 948 | 
 949 | 
 950 | class EmptyResultException(Exception):
 951 |     pass
 952 | 
 953 | 
 954 | class BaseQuery(object):
 955 |     query_separator = '__'
 956 |     force_alias = False
 957 | 
 958 |     def __init__(self, model):
 959 |         self.model = model
 960 |         self.query_context = model
 961 |         self.database = self.model._meta.database
 962 |         self.operations = self.database.adapter.operations
 963 |         self.interpolation = self.database.adapter.interpolation
 964 | 
 965 |         self._dirty = True
 966 |         self._where = []
 967 |         self._where_models = set()
 968 |         self._joins = {}
 969 |         self._joined_models = set()
 970 |         self._table_alias = {}
 971 | 
 972 |     def _clone_dict_graph(self, dg):
 973 |         cloned = {}
 974 |         for node, edges in dg.items():
 975 |             cloned[node] = list(edges)
 976 |         return cloned
 977 | 
 978 |     def clone_where(self):
 979 |         return list(self._where)
 980 | 
 981 |     def clone_joins(self):
 982 |         return self._clone_dict_graph(self._joins)
 983 | 
 984 |     def clone(self):
 985 |         raise NotImplementedError
 986 | 
 987 |     def qn(self, name):
 988 |         return self.database.quote_name(name)
 989 | 
 990 |     def lookup_cast(self, lookup, value):
 991 |         return self.database.adapter.lookup_cast(lookup, value)
 992 | 
 993 |     def parse_query_args(self, _model, **query):
 994 |         """
 995 |         Parse out and normalize clauses in a query.  The query is composed of
 996 |         various column+lookup-type/value pairs.  Validates that the lookups
 997 |         are valid and returns a list of lookup tuples that have the form:
 998 |         (field name, (operation, value))
 999 |         """
1000 |         model = _model
1001 |         parsed = []
1002 |         for lhs, rhs in query.iteritems():
1003 |             if self.query_separator in lhs:
1004 |                 lhs, op = lhs.rsplit(self.query_separator, 1)
1005 |             else:
1006 |                 op = 'eq'
1007 | 
1008 |             if lhs in model._meta.columns:
1009 |                 lhs = model._meta.columns[lhs].name
1010 | 
1011 |             try:
1012 |                 field = model._meta.get_field_by_name(lhs)
1013 |             except AttributeError:
1014 |                 field = model._meta.get_related_field_by_name(lhs)
1015 |                 if field is None:
1016 |                     raise
1017 | 
1018 |             if isinstance(rhs, R):
1019 |                 expr, params = rhs.sql_where()
1020 |                 lookup_value = [field.db_value(o) for o in params]
1021 | 
1022 |                 combined_expr = self.operations[op] % expr
1023 |                 operation = combined_expr % tuple(self.interpolation for p in params)
1024 |             elif isinstance(rhs, F):
1025 |                 lookup_value = rhs
1026 |                 operation = self.operations[op] # leave as "%s"
1027 |             else:
1028 |                 if op == 'in':
1029 |                     if isinstance(rhs, SelectQuery):
1030 |                         lookup_value = rhs
1031 |                         operation = 'IN (%s)'
1032 |                     else:
1033 |                         if not rhs:
1034 |                             raise EmptyResultException
1035 |                         lookup_value = [field.db_value(o) for o in rhs]
1036 |                         operation = self.operations[op] % \
1037 |                             (','.join([self.interpolation for v in lookup_value]))
1038 |                 elif op == 'is':
1039 |                     if rhs is not None:
1040 |                         raise ValueError('__is lookups only accept None')
1041 |                     operation = 'IS NULL'
1042 |                     lookup_value = []
1043 |                 elif op == 'isnull':
1044 |                     operation = 'IS NULL' if rhs else 'IS NOT NULL'
1045 |                     lookup_value = []
1046 |                 elif isinstance(rhs, (list, tuple)):
1047 |                     # currently this only happens on 'between' lookups, but leave
1048 |                     # it general to lists and tuples
1049 |                     lookup_value = [field.db_value(o) for o in rhs]
1050 |                     operation = self.operations[op] % \
1051 |                         tuple(self.interpolation for v in lookup_value)
1052 |                 else:
1053 |                     lookup_value = field.db_value(rhs)
1054 |                     operation = self.operations[op] % self.interpolation
1055 | 
1056 |             parsed.append(
1057 |                 (field.db_column, (operation, self.lookup_cast(op, lookup_value)))
1058 |             )
1059 | 
1060 |         return parsed
1061 | 
1062 |     @returns_clone
1063 |     def where(self, *args, **kwargs):
1064 |         parsed = parseq(self.query_context, *args, **kwargs)
1065 |         if parsed:
1066 |             self._where.append(parsed)
1067 |             self._where_models.update(find_models(parsed))
1068 | 
1069 |     @returns_clone
1070 |     def join(self, model, join_type=None, on=None, alias=None):
1071 |         if self.query_context._meta.rel_exists(model):
1072 |             self._joined_models.add(model)
1073 |             self._joins.setdefault(self.query_context, [])
1074 |             self._joins[self.query_context].append((model, join_type, on))
1075 |             if alias:
1076 |                 self._table_alias[model] = alias
1077 |             self.query_context = model
1078 |         else:
1079 |             raise AttributeError('No foreign key found between %s and %s' % \
1080 |                 (self.query_context.__name__, model.__name__))
1081 | 
1082 |     @returns_clone
1083 |     def switch(self, model):
1084 |         if model == self.model:
1085 |             self.query_context = model
1086 |             return
1087 | 
1088 |         if model in self._joined_models:
1089 |             self.query_context = model
1090 |             return
1091 |         raise AttributeError('You must JOIN on %s' % model.__name__)
1092 | 
1093 |     def use_aliases(self):
1094 |         return len(self._joined_models) > 0 or self.force_alias
1095 | 
1096 |     def combine_field(self, alias, field_col):
1097 |         quoted = self.qn(field_col)
1098 |         if alias:
1099 |             return '%s.%s' % (alias, quoted)
1100 |         return quoted
1101 | 
1102 |     def safe_combine(self, model, alias, col):
1103 |         if col in model._meta.columns:
1104 |             return self.combine_field(alias, col)
1105 |         elif col in model._meta.fields:
1106 |             return self.combine_field(alias, model._meta.fields[col].db_column)
1107 |         return col
1108 | 
1109 |     def follow_joins(self, current, alias_map, alias_required, alias_count, seen=None):
1110 |         computed = []
1111 |         seen = seen or set()
1112 | 
1113 |         if current not in self._joins:
1114 |             return computed
1115 | 
1116 |         for i, (model, join_type, on) in enumerate(self._joins[current]):
1117 |             seen.add(model)
1118 | 
1119 |             if alias_required:
1120 |                 if model in self._table_alias:
1121 |                     alias_map[model] = self._table_alias[model]
1122 |                 else:
1123 |                     alias_count += 1
1124 |                     alias_map[model] = 't%d' % alias_count
1125 |             else:
1126 |                 alias_map[model] = ''
1127 | 
1128 |             from_model = current
1129 |             field = from_model._meta.get_related_field_for_model(model, on)
1130 |             if field:
1131 |                 left_field = field.db_column
1132 |                 right_field = model._meta.pk_col
1133 |             else:
1134 |                 field = from_model._meta.get_reverse_related_field_for_model(model, on)
1135 |                 left_field = from_model._meta.pk_col
1136 |                 right_field = field.db_column
1137 | 
1138 |             if join_type is None:
1139 |                 if field.null and model not in self._where_models:
1140 |                     join_type = 'LEFT OUTER'
1141 |                 else:
1142 |                     join_type = 'INNER'
1143 | 
1144 |             computed.append(
1145 |                 '%s JOIN %s AS %s ON %s = %s' % (
1146 |                     join_type,
1147 |                     self.qn(model._meta.db_table),
1148 |                     alias_map[model],
1149 |                     self.combine_field(alias_map[from_model], left_field),
1150 |                     self.combine_field(alias_map[model], right_field),
1151 |                 )
1152 |             )
1153 | 
1154 |             computed.extend(self.follow_joins(model, alias_map, alias_required, alias_count, seen))
1155 | 
1156 |         return computed
1157 | 
1158 |     def compile_where(self):
1159 |         alias_count = 0
1160 |         alias_map = {}
1161 | 
1162 |         alias_required = self.use_aliases()
1163 |         if alias_required:
1164 |             if self.model in self._table_alias:
1165 |                 alias_map[self.model] = self._table_alias[self.model]
1166 |             else:
1167 |                 alias_count += 1
1168 |                 alias_map[self.model] = 't%d' % alias_count
1169 |         else:
1170 |             alias_map[self.model] = ''
1171 | 
1172 |         computed_joins = self.follow_joins(self.model, alias_map, alias_required, alias_count)
1173 | 
1174 |         clauses = [self.parse_node(node, alias_map) for node in self._where]
1175 | 
1176 |         return computed_joins, clauses, alias_map
1177 | 
1178 |     def flatten_clauses(self, clauses):
1179 |         where_with_alias = []
1180 |         where_data = []
1181 |         for query, data in clauses:
1182 |             where_with_alias.append(query)
1183 |             where_data.extend(data)
1184 |         return where_with_alias, where_data
1185 | 
1186 |     def convert_where_to_params(self, where_data):
1187 |         flattened = []
1188 |         for clause in where_data:
1189 |             if isinstance(clause, (tuple, list)):
1190 |                 flattened.extend(clause)
1191 |             else:
1192 |                 flattened.append(clause)
1193 |         return flattened
1194 | 
1195 |     def parse_node(self, node, alias_map):
1196 |         query = []
1197 |         query_data = []
1198 |         for child in node.children:
1199 |             if isinstance(child, Q):
1200 |                 parsed, data = self.parse_q(child, alias_map)
1201 |                 query.append(parsed)
1202 |                 query_data.extend(data)
1203 |             elif isinstance(child, R):
1204 |                 parsed, data = self.parse_r(child, alias_map)
1205 |                 query.append(parsed % tuple(self.interpolation for o in data))
1206 |                 query_data.extend(data)
1207 |             elif isinstance(child, Node):
1208 |                 parsed, data = self.parse_node(child, alias_map)
1209 |                 query.append('(%s)' % parsed)
1210 |                 query_data.extend(data)
1211 |         connector = ' %s ' % node.connector
1212 |         query = connector.join(query)
1213 |         if node.negated:
1214 |             query = 'NOT (%s)' % query
1215 |         return query, query_data
1216 | 
1217 |     def parse_q(self, q, alias_map):
1218 |         model = q.model or self.model
1219 |         query = []
1220 |         query_data = []
1221 |         parsed = self.parse_query_args(model, **q.query)
1222 |         for (name, lookup) in parsed:
1223 |             operation, value = lookup
1224 |             if isinstance(value, SelectQuery):
1225 |                 sql, value = self.convert_subquery(value)
1226 |                 operation = operation % sql
1227 | 
1228 |             if isinstance(value, F):
1229 |                 f_model = value.model or model
1230 |                 operation = operation % self.parse_f(value, f_model, alias_map)
1231 |             else:
1232 |                 query_data.append(value)
1233 | 
1234 |             combined = self.combine_field(alias_map[model], name)
1235 |             query.append('%s %s' % (combined, operation))
1236 | 
1237 |         if len(query) > 1:
1238 |             query = '(%s)' % (' AND '.join(query))
1239 |         else:
1240 |             query = query[0]
1241 | 
1242 |         if q.negated:
1243 |             query = 'NOT %s' % query
1244 | 
1245 |         return query, query_data
1246 | 
1247 |     def parse_f(self, f_object, model, alias_map):
1248 |         combined = self.combine_field(alias_map[model], f_object.field)
1249 |         if f_object.op is not None:
1250 |             combined = '(%s %s %s)' % (combined, f_object.op, f_object.value)
1251 | 
1252 |         return combined
1253 | 
1254 |     def parse_r(self, r_object, alias_map):
1255 |         return r_object.sql_where()
1256 | 
1257 |     def convert_subquery(self, subquery):
1258 |         orig_query = subquery.query
1259 |         if subquery.query == '*':
1260 |             subquery.query = subquery.model._meta.pk_name
1261 | 
1262 |         subquery.force_alias, orig_alias = True, subquery.force_alias
1263 |         sql, data = subquery.sql()
1264 |         subquery.query = orig_query
1265 |         subquery.force_alias = orig_alias
1266 |         return sql, data
1267 | 
1268 |     def sorted_models(self, alias_map):
1269 |         return [
1270 |             (model, alias) \
1271 |                 for (model, alias) in sorted(alias_map.items(), key=lambda i: i[1])
1272 |         ]
1273 | 
1274 |     def sql(self):
1275 |         raise NotImplementedError
1276 | 
1277 |     def execute(self):
1278 |         raise NotImplementedError
1279 | 
1280 |     def raw_execute(self, query, params):
1281 |         return self.database.execute(query, params)
1282 | 
1283 | 
1284 | class RawQuery(BaseQuery):
1285 |     def __init__(self, model, query, *params):
1286 |         self._sql = query
1287 |         self._params = list(params)
1288 |         super(RawQuery, self).__init__(model)
1289 | 
1290 |     def clone(self):
1291 |         return RawQuery(self.model, self._sql, *self._params)
1292 | 
1293 |     def sql(self):
1294 |         return self._sql, self._params
1295 | 
1296 |     def execute(self):
1297 |         return QueryResultWrapper(self.model, self.raw_execute(*self.sql()))
1298 | 
1299 |     def join(self):
1300 |         raise AttributeError('Raw queries do not support joining programmatically')
1301 | 
1302 |     def where(self):
1303 |         raise AttributeError('Raw queries do not support querying programmatically')
1304 | 
1305 |     def switch(self):
1306 |         raise AttributeError('Raw queries do not support switching contexts')
1307 | 
1308 |     def __iter__(self):
1309 |         return iter(self.execute())
1310 | 
1311 | 
1312 | class SelectQuery(BaseQuery):
1313 |     def __init__(self, model, query=None):
1314 |         self.query = query or '*'
1315 |         self._group_by = []
1316 |         self._having = []
1317 |         self._order_by = []
1318 |         self._limit = None
1319 |         self._offset = None
1320 |         self._distinct = False
1321 |         self._qr = None
1322 |         self._for_update = False
1323 |         self._naive = False
1324 |         super(SelectQuery, self).__init__(model)
1325 | 
1326 |     def clone(self):
1327 |         query = SelectQuery(self.model, self.query)
1328 |         query.query_context = self.query_context
1329 |         query._group_by = list(self._group_by)
1330 |         query._having = list(self._having)
1331 |         query._order_by = list(self._order_by)
1332 |         query._limit = self._limit
1333 |         query._offset = self._offset
1334 |         query._distinct = self._distinct
1335 |         query._qr = self._qr
1336 |         query._for_update = self._for_update
1337 |         query._naive = self._naive
1338 |         query._where = self.clone_where()
1339 |         query._where_models = set(self._where_models)
1340 |         query._joined_models = self._joined_models.copy()
1341 |         query._joins = self.clone_joins()
1342 |         query._table_alias = dict(self._table_alias)
1343 |         return query
1344 | 
1345 |     @returns_clone
1346 |     def paginate(self, page, paginate_by=20):
1347 |         if page > 0:
1348 |             page -= 1
1349 |         self._limit = paginate_by
1350 |         self._offset = page * paginate_by
1351 | 
1352 |     @returns_clone
1353 |     def limit(self, num_rows):
1354 |         self._limit = num_rows
1355 | 
1356 |     @returns_clone
1357 |     def offset(self, num_rows):
1358 |         self._offset = num_rows
1359 | 
1360 |     @returns_clone
1361 |     def for_update(self, for_update=True):
1362 |         self._for_update = for_update
1363 | 
1364 |     def count(self):
1365 |         if self._distinct or self._group_by:
1366 |             return self.wrapped_count()
1367 | 
1368 |         clone = self.order_by()
1369 |         clone._limit = clone._offset = None
1370 | 
1371 |         if clone.use_aliases():
1372 |             clone.query = 'COUNT(t1.%s)' % (clone.model._meta.pk_col)
1373 |         else:
1374 |             clone.query = 'COUNT(%s)' % (clone.model._meta.pk_col)
1375 | 
1376 |         res = clone.database.execute(*clone.sql())
1377 | 
1378 |         return (res.fetchone() or [0])[0]
1379 | 
1380 |     def wrapped_count(self):
1381 |         clone = self.order_by()
1382 |         clone._limit = clone._offset = None
1383 | 
1384 |         sql, params = clone.sql()
1385 |         query = 'SELECT COUNT(1) FROM (%s) AS wrapped_select' % sql
1386 | 
1387 |         res = clone.database.execute(query, params)
1388 | 
1389 |         return res.fetchone()[0]
1390 | 
1391 |     @returns_clone
1392 |     def group_by(self, *clauses):
1393 |         model = self.query_context
1394 |         for clause in clauses:
1395 |             if isinstance(clause, basestring):
1396 |                 fields = (clause,)
1397 |             elif isinstance(clause, (list, tuple)):
1398 |                 fields = clause
1399 |             elif issubclass(clause, Model):
1400 |                 model = clause
1401 |                 fields = clause._meta.get_field_names()
1402 | 
1403 |             self._group_by.append((model, fields))
1404 | 
1405 |     @returns_clone
1406 |     def having(self, *clauses):
1407 |         self._having = clauses
1408 | 
1409 |     @returns_clone
1410 |     def distinct(self):
1411 |         self._distinct = True
1412 | 
1413 |     @returns_clone
1414 |     def order_by(self, *clauses):
1415 |         order_by = []
1416 | 
1417 |         for clause in clauses:
1418 |             if isinstance(clause, tuple):
1419 |                 if len(clause) == 3:
1420 |                     model, field, ordering = clause
1421 |                 elif len(clause) == 2:
1422 |                     if isinstance(clause[0], basestring):
1423 |                         model = self.query_context
1424 |                         field, ordering = clause
1425 |                     else:
1426 |                         model, field = clause
1427 |                         ordering = 'ASC'
1428 |                 else:
1429 |                     raise ValueError('Incorrect arguments passed in order_by clause')
1430 |             else:
1431 |                 model = self.query_context
1432 |                 field = clause
1433 |                 ordering = 'ASC'
1434 | 
1435 |             order_by.append(
1436 |                 (model, field, ordering)
1437 |             )
1438 | 
1439 |         self._order_by = order_by
1440 | 
1441 |     def exists(self):
1442 |         clone = self.paginate(1, 1)
1443 |         clone.query = '(1) AS a'
1444 |         curs = self.database.execute(*clone.sql())
1445 |         return bool(curs.fetchone())
1446 | 
1447 |     def get(self, *args, **kwargs):
1448 |         orig_ctx = self.query_context
1449 |         self.query_context = self.model
1450 |         query = self.where(*args, **kwargs).paginate(1, 1)
1451 |         try:
1452 |             obj = query.execute().next()
1453 |             return obj
1454 |         except StopIteration:
1455 |             raise self.model.DoesNotExist('instance matching query does not exist:\nSQL: %s\nPARAMS: %s' % (
1456 |                 query.sql()
1457 |             ))
1458 |         finally:
1459 |             self.query_context = orig_ctx
1460 | 
1461 |     def filter(self, *args, **kwargs):
1462 |         return filter_query(self, *args, **kwargs)
1463 | 
1464 |     def annotate(self, related_model, aggregation=None):
1465 |         return annotate_query(self, related_model, aggregation)
1466 | 
1467 |     def aggregate(self, func):
1468 |         clone = self.order_by()
1469 |         clone.query = [func]
1470 |         curs = self.database.execute(*clone.sql())
1471 |         return curs.fetchone()[0]
1472 | 
1473 |     @returns_clone
1474 |     def naive(self, make_naive=True):
1475 |         self._naive = make_naive
1476 | 
1477 |     def parse_select_query(self, alias_map):
1478 |         q = self.query
1479 | 
1480 |         if isinstance(q, (list, tuple)):
1481 |             q = {self.model: self.query}
1482 |         elif isinstance(q, basestring):
1483 |             # convert '*' and primary key lookups
1484 |             if q == '*':
1485 |                 q = {self.model: self.model._meta.get_field_names()}
1486 |             elif q in (self.model._meta.pk_col, self.model._meta.pk_name):
1487 |                 q = {self.model: [self.model._meta.pk_name]}
1488 |             else:
1489 |                 return q, []
1490 | 
1491 |         # by now we should have a dictionary if a valid type was passed in
1492 |         if not isinstance(q, dict):
1493 |             raise TypeError('Unknown type encountered parsing select query')
1494 | 
1495 |         # gather aliases and models
1496 |         sorted_models = self.sorted_models(alias_map)
1497 | 
1498 |         # normalize if we are working with a dictionary
1499 |         columns = []
1500 |         model_cols = []
1501 | 
1502 |         for model, alias in sorted_models:
1503 |             if model not in q:
1504 |                 continue
1505 | 
1506 |             if '*' in q[model]:
1507 |                 idx = q[model].index('*')
1508 |                 q[model] =  q[model][:idx] + model._meta.get_field_names() + q[model][idx+1:]
1509 | 
1510 |             for clause in q[model]:
1511 |                 if isinstance(clause, R):
1512 |                     clause = clause.sql_select()
1513 | 
1514 |                 if isinstance(clause, tuple):
1515 |                     if len(clause) == 3:
1516 |                         func, col_name, col_alias = clause
1517 |                         column = model._meta.get_column(col_name)
1518 |                         columns.append('%s(%s) AS %s' % \
1519 |                             (func, self.safe_combine(model, alias, column), col_alias)
1520 |                         )
1521 |                         model_cols.append((model, (func, column, col_alias)))
1522 |                     elif len(clause) == 2:
1523 |                         col_name, col_alias = clause
1524 |                         column = model._meta.get_column(col_name)
1525 |                         columns.append('%s AS %s' % \
1526 |                             (self.safe_combine(model, alias, column), col_alias)
1527 |                         )
1528 |                         model_cols.append((model, (column, col_alias)))
1529 |                     else:
1530 |                         raise ValueError('Clause must be either a 2- or 3-tuple')
1531 |                 else:
1532 |                     column = model._meta.get_column(clause)
1533 |                     columns.append(self.safe_combine(model, alias, column))
1534 |                     model_cols.append((model, column))
1535 | 
1536 |         return ', '.join(columns), model_cols
1537 | 
1538 | 
1539 |     def sql_meta(self):
1540 |         joins, clauses, alias_map = self.compile_where()
1541 |         where, where_data = self.flatten_clauses(clauses)
1542 | 
1543 |         table = self.qn(self.model._meta.db_table)
1544 | 
1545 |         params = []
1546 |         group_by = []
1547 |         use_aliases = self.use_aliases()
1548 | 
1549 |         if use_aliases:
1550 |             table = '%s AS %s' % (table, alias_map[self.model])
1551 | 
1552 |         for model, clause in self._group_by:
1553 |             if use_aliases:
1554 |                 alias = alias_map[model]
1555 |             else:
1556 |                 alias = ''
1557 | 
1558 |             for field in clause:
1559 |                 group_by.append(self.safe_combine(model, alias, field))
1560 | 
1561 |         parsed_query, model_cols = self.parse_select_query(alias_map)
1562 |         query_meta = {
1563 |             'columns': model_cols,
1564 |             'graph': self._joins,
1565 |         }
1566 | 
1567 |         if self._distinct:
1568 |             sel = 'SELECT DISTINCT'
1569 |         else:
1570 |             sel = 'SELECT'
1571 | 
1572 |         select = '%s %s FROM %s' % (sel, parsed_query, table)
1573 |         joins = '\n'.join(joins)
1574 |         where = ' AND '.join(where)
1575 |         group_by = ', '.join(group_by)
1576 |         having = ' AND '.join(self._having)
1577 | 
1578 |         order_by = []
1579 |         for piece in self._order_by:
1580 |             model, field, ordering = piece
1581 |             if use_aliases:
1582 |                 alias = alias_map[model]
1583 |             else:
1584 |                 alias = ''
1585 | 
1586 |             order_by.append('%s %s' % (self.safe_combine(model, alias, field), ordering))
1587 | 
1588 |         pieces = [select]
1589 | 
1590 |         if joins:
1591 |             pieces.append(joins)
1592 |         if where:
1593 |             pieces.append('WHERE %s' % where)
1594 |             params.extend(self.convert_where_to_params(where_data))
1595 | 
1596 |         if group_by:
1597 |             pieces.append('GROUP BY %s' % group_by)
1598 |         if having:
1599 |             pieces.append('HAVING %s' % having)
1600 |         if order_by:
1601 |             pieces.append('ORDER BY %s' % ', '.join(order_by))
1602 |         if self._limit:
1603 |             pieces.append('LIMIT %d' % self._limit)
1604 |         if self._offset:
1605 |             pieces.append('OFFSET %d' % self._offset)
1606 | 
1607 |         if self._for_update and self.database.adapter.for_update_support:
1608 |             pieces.append('FOR UPDATE')
1609 | 
1610 |         return ' '.join(pieces), params, query_meta
1611 | 
1612 |     def sql(self):
1613 |         query, params, meta = self.sql_meta()
1614 |         return query, params
1615 | 
1616 |     def execute(self):
1617 |         if self._dirty or not self._qr:
1618 |             try:
1619 |                 sql, params, meta = self.sql_meta()
1620 |             except EmptyResultException:
1621 |                 return []
1622 |             else:
1623 |                 if self._naive:
1624 |                     meta = None
1625 |                 self._qr = QueryResultWrapper(self.model, self.raw_execute(sql, params), meta)
1626 |                 self._dirty = False
1627 |                 return self._qr
1628 |         else:
1629 |             # call the __iter__ method directly
1630 |             return self._qr
1631 | 
1632 |     def __iter__(self):
1633 |         return iter(self.execute())
1634 | 
1635 | 
1636 | class UpdateQuery(BaseQuery):
1637 |     def __init__(self, _model, **kwargs):
1638 |         self.update_query = kwargs
1639 |         super(UpdateQuery, self).__init__(_model)
1640 | 
1641 |     def clone(self):
1642 |         query = UpdateQuery(self.model, **self.update_query)
1643 |         query._where = self.clone_where()
1644 |         query._where_models = set(self._where_models)
1645 |         query._joined_models = self._joined_models.copy()
1646 |         query._joins = self.clone_joins()
1647 |         query._table_alias = dict(self._table_alias)
1648 |         return query
1649 | 
1650 |     def parse_update(self):
1651 |         sets = {}
1652 |         for k, v in self.update_query.iteritems():
1653 |             if k in self.model._meta.columns:
1654 |                 k = self.model._meta.columns[k].name
1655 | 
1656 |             try:
1657 |                 field = self.model._meta.get_field_by_name(k)
1658 |             except AttributeError:
1659 |                 field = self.model._meta.get_related_field_by_name(k)
1660 |                 if field is None:
1661 |                     raise
1662 | 
1663 |             if not isinstance(v, F):
1664 |                 v = field.db_value(v)
1665 | 
1666 |             sets[field.db_column] = v
1667 | 
1668 |         return sets
1669 | 
1670 |     def sql(self):
1671 |         joins, clauses, alias_map = self.compile_where()
1672 |         where, where_data = self.flatten_clauses(clauses)
1673 |         set_statement = self.parse_update()
1674 | 
1675 |         params = []
1676 |         update_params = []
1677 | 
1678 |         alias = alias_map.get(self.model)
1679 | 
1680 |         for k, v in sorted(set_statement.items(), key=lambda (k, v): k):
1681 |             if isinstance(v, F):
1682 |                 value = self.parse_f(v, v.model or self.model, alias_map)
1683 |             else:
1684 |                 params.append(v)
1685 |                 value = self.interpolation
1686 | 
1687 |             update_params.append('%s=%s' % (self.combine_field(alias, k), value))
1688 | 
1689 |         update = 'UPDATE %s SET %s' % (
1690 |             self.qn(self.model._meta.db_table), ', '.join(update_params))
1691 |         where = ' AND '.join(where)
1692 | 
1693 |         pieces = [update]
1694 | 
1695 |         if where:
1696 |             pieces.append('WHERE %s' % where)
1697 |             params.extend(self.convert_where_to_params(where_data))
1698 | 
1699 |         return ' '.join(pieces), params
1700 | 
1701 |     def join(self, *args, **kwargs):
1702 |         raise AttributeError('Update queries do not support JOINs in sqlite')
1703 | 
1704 |     def execute(self):
1705 |         result = self.raw_execute(*self.sql())
1706 |         return self.database.rows_affected(result)
1707 | 
1708 | 
1709 | class DeleteQuery(BaseQuery):
1710 |     def clone(self):
1711 |         query = DeleteQuery(self.model)
1712 |         query._where = self.clone_where()
1713 |         query._where_models = set(self._where_models)
1714 |         query._joined_models = self._joined_models.copy()
1715 |         query._joins = self.clone_joins()
1716 |         query._table_alias = dict(self._table_alias)
1717 |         return query
1718 | 
1719 |     def sql(self):
1720 |         joins, clauses, alias_map = self.compile_where()
1721 |         where, where_data = self.flatten_clauses(clauses)
1722 | 
1723 |         params = []
1724 | 
1725 |         delete = 'DELETE FROM %s' % (self.qn(self.model._meta.db_table))
1726 |         where = ' AND '.join(where)
1727 | 
1728 |         pieces = [delete]
1729 | 
1730 |         if where:
1731 |             pieces.append('WHERE %s' % where)
1732 |             params.extend(self.convert_where_to_params(where_data))
1733 | 
1734 |         return ' '.join(pieces), params
1735 | 
1736 |     def join(self, *args, **kwargs):
1737 |         raise AttributeError('Update queries do not support JOINs in sqlite')
1738 | 
1739 |     def execute(self):
1740 |         result = self.raw_execute(*self.sql())
1741 |         return self.database.rows_affected(result)
1742 | 
1743 | 
1744 | class InsertQuery(BaseQuery):
1745 |     def __init__(self, _model, **kwargs):
1746 |         self.insert_query = kwargs
1747 |         super(InsertQuery, self).__init__(_model)
1748 | 
1749 |     def parse_insert(self):
1750 |         cols = []
1751 |         vals = []
1752 |         for k, v in sorted(self.insert_query.items(), key=lambda (k, v): k):
1753 |             if k in self.model._meta.columns:
1754 |                 k = self.model._meta.columns[k].name
1755 | 
1756 |             try:
1757 |                 field = self.model._meta.get_field_by_name(k)
1758 |             except AttributeError:
1759 |                 field = self.model._meta.get_related_field_by_name(k)
1760 |                 if field is None:
1761 |                     raise
1762 | 
1763 |             cols.append(self.qn(field.db_column))
1764 |             vals.append(field.db_value(v))
1765 | 
1766 |         return cols, vals
1767 | 
1768 |     def sql(self):
1769 |         cols, vals = self.parse_insert()
1770 | 
1771 |         insert = 'INSERT INTO %s (%s) VALUES (%s)' % (
1772 |             self.qn(self.model._meta.db_table),
1773 |             ','.join(cols),
1774 |             ','.join(self.interpolation for v in vals)
1775 |         )
1776 | 
1777 |         return insert, vals
1778 | 
1779 |     def where(self, *args, **kwargs):
1780 |         raise AttributeError('Insert queries do not support WHERE clauses')
1781 | 
1782 |     def join(self, *args, **kwargs):
1783 |         raise AttributeError('Insert queries do not support JOINs')
1784 | 
1785 |     def execute(self):
1786 |         result = self.raw_execute(*self.sql())
1787 |         return self.database.last_insert_id(result, self.model)
1788 | 
1789 | 
1790 | def model_or_select(m_or_q):
1791 |     """
1792 |     Return both a model and a select query for the provided model *OR* select
1793 |     query.
1794 |     """
1795 |     if isinstance(m_or_q, BaseQuery):
1796 |         return (m_or_q.model, m_or_q)
1797 |     else:
1798 |         return (m_or_q, m_or_q.select())
1799 | 
1800 | def convert_lookup(model, joins, lookup):
1801 |     """
1802 |     Given a model, a graph of joins, and a lookup, return a tuple containing
1803 |     a normalized lookup:
1804 | 
1805 |     (model actually being queried, updated graph of joins, normalized lookup)
1806 |     """
1807 |     operations = model._meta.database.adapter.operations
1808 | 
1809 |     pieces = lookup.split('__')
1810 |     operation = None
1811 | 
1812 |     query_model = model
1813 | 
1814 |     if len(pieces) > 1:
1815 |         if pieces[-1] in operations:
1816 |             operation = pieces.pop()
1817 | 
1818 |         lookup = pieces.pop()
1819 | 
1820 |         # we have some joins
1821 |         if len(pieces):
1822 |             for piece in pieces:
1823 |                 # piece is something like 'blog' or 'entry_set'
1824 |                 joined_model = None
1825 |                 for field in query_model._meta.get_fields():
1826 |                     if not isinstance(field, ForeignKeyField):
1827 |                         continue
1828 | 
1829 |                     if piece in (field.name, field.db_column, field.related_name):
1830 |                         joined_model = field.to
1831 | 
1832 |                 if not joined_model:
1833 |                     try:
1834 |                         joined_model = query_model._meta.reverse_relations[piece]
1835 |                     except KeyError:
1836 |                         raise ValueError('Unknown relation: "%s" of "%s"' % (
1837 |                             piece,
1838 |                             query_model,
1839 |                         ))
1840 | 
1841 |                 joins.setdefault(query_model, set())
1842 |                 joins[query_model].add(joined_model)
1843 |                 query_model = joined_model
1844 | 
1845 |     if operation:
1846 |         lookup = '%s__%s' % (lookup, operation)
1847 | 
1848 |     return query_model, joins, lookup
1849 | 
1850 | 
1851 | def filter_query(model_or_query, *args, **kwargs):
1852 |     """
1853 |     Provide a django-like interface for executing queries
1854 |     """
1855 |     model, select_query = model_or_select(model_or_query)
1856 | 
1857 |     query = {} # mapping of models to queries
1858 |     joins = {} # a graph of joins needed, passed into the convert_lookup function
1859 | 
1860 |     # traverse Q() objects, find any joins that may be lurking -- clean up the
1861 |     # lookups and assign the correct model
1862 |     def fix_q(node_or_q, joins):
1863 |         if isinstance(node_or_q, Node):
1864 |             for child in node_or_q.children:
1865 |                 fix_q(child, joins)
1866 |         elif isinstance(node_or_q, Q):
1867 |             new_query = {}
1868 |             curr_model = node_or_q.model or model
1869 |             for raw_lookup, value in node_or_q.query.items():
1870 |                 query_model, joins, lookup = convert_lookup(curr_model, joins, raw_lookup)
1871 |                 new_query[lookup] = value
1872 |             node_or_q.model = query_model
1873 |             node_or_q.query = new_query
1874 | 
1875 |     for node_or_q in args:
1876 |         fix_q(node_or_q, joins)
1877 | 
1878 |     # iterate over keyword lookups and determine lookups and necessary joins
1879 |     for raw_lookup, value in kwargs.items():
1880 |         queried_model, joins, lookup = convert_lookup(model, joins, raw_lookup)
1881 |         query.setdefault(queried_model, [])
1882 |         query[queried_model].append((lookup, value))
1883 | 
1884 |     def follow_joins(current, query):
1885 |         if current in joins:
1886 |             for joined_model in joins[current]:
1887 |                 query = query.switch(current)
1888 |                 if joined_model not in query._joined_models:
1889 |                     query = query.join(joined_model)
1890 |                 query = follow_joins(joined_model, query)
1891 |         return query
1892 |     select_query = follow_joins(model, select_query)
1893 | 
1894 |     for node in args:
1895 |         select_query = select_query.where(node)
1896 | 
1897 |     for model, lookups in query.items():
1898 |         qargs, qkwargs = [], {}
1899 |         for lookup in lookups:
1900 |             if isinstance(lookup, tuple):
1901 |                 qkwargs[lookup[0]] = lookup[1]
1902 |             else:
1903 |                 qargs.append(lookup)
1904 |         select_query = select_query.switch(model).where(*qargs, **qkwargs)
1905 | 
1906 |     return select_query
1907 | 
1908 | def annotate_query(select_query, related_model, aggregation):
1909 |     """
1910 |     Perform an aggregation against a related model
1911 |     """
1912 |     aggregation = aggregation or Count(related_model._meta.pk_name)
1913 |     model = select_query.model
1914 | 
1915 |     select_query = select_query.switch(model)
1916 |     cols = select_query.query
1917 | 
1918 |     # ensure the join is there
1919 |     if related_model not in select_query._joined_models:
1920 |         select_query = select_query.join(related_model).switch(model)
1921 | 
1922 |     # query for it
1923 |     if isinstance(cols, dict):
1924 |         selection = cols
1925 |         group_by = cols[model]
1926 |     elif isinstance(cols, basestring):
1927 |         selection = {model: [cols]}
1928 |         if cols == '*':
1929 |             group_by = model
1930 |         else:
1931 |             group_by = [col.strip() for col in cols.split(',')]
1932 |     elif isinstance(cols, (list, tuple)):
1933 |         selection = {model: cols}
1934 |         group_by = cols
1935 |     else:
1936 |         raise ValueError('Unknown type passed in to select query: "%s"' % type(cols))
1937 | 
1938 |     # query for the related object
1939 |     selection[related_model] = [aggregation]
1940 | 
1941 |     select_query.query = selection
1942 |     return select_query.group_by(group_by)
1943 | 
1944 | 
1945 | class Column(object):
1946 |     db_field = ''
1947 |     template = '%(column_type)s'
1948 | 
1949 |     def __init__(self, **attributes):
1950 |         self.attributes = self.get_attributes()
1951 |         self.attributes.update(**attributes)
1952 | 
1953 |     def get_attributes(self):
1954 |         return {}
1955 | 
1956 |     def python_value(self, value):
1957 |         return value
1958 | 
1959 |     def db_value(self, value):
1960 |         return value
1961 | 
1962 |     def render(self, db):
1963 |         params = {'column_type': db.column_for_field_type(self.db_field)}
1964 |         params.update(self.attributes)
1965 |         return self.template % params
1966 | 
1967 | 
1968 | class VarCharColumn(Column):
1969 |     db_field = 'string'
1970 |     template = '%(column_type)s(%(max_length)d)'
1971 | 
1972 |     def get_attributes(self):
1973 |         return {'max_length': 255}
1974 | 
1975 |     def db_value(self, value):
1976 |         value = unicode(value or '')
1977 |         return value[:self.attributes['max_length']]
1978 | 
1979 | 
1980 | class TextColumn(Column):
1981 |     db_field = 'text'
1982 | 
1983 |     def db_value(self, value):
1984 |         return value or ''
1985 | 
1986 | def format_date_time(value, formats, post_process=None):
1987 |     post_process = post_process or (lambda x: x)
1988 |     for fmt in formats:
1989 |         try:
1990 |             return post_process(datetime.datetime.strptime(value, fmt))
1991 |         except ValueError:
1992 |             pass
1993 |     return value
1994 | 
1995 | 
1996 | class DateTimeColumn(Column):
1997 |     db_field = 'datetime'
1998 | 
1999 |     def get_attributes(self):
2000 |         return {
2001 |             'formats': [
2002 |                 '%Y-%m-%d %H:%M:%S.%f',
2003 |                 '%Y-%m-%d %H:%M:%S',
2004 |                 '%Y-%m-%d',
2005 |             ]
2006 |         }
2007 | 
2008 |     def python_value(self, value):
2009 |         if isinstance(value, basestring):
2010 |             return format_date_time(value, self.attributes['formats'])
2011 |         return value
2012 | 
2013 | 
2014 | class DateColumn(Column):
2015 |     db_field = 'date'
2016 | 
2017 |     def get_attributes(self):
2018 |         return {
2019 |             'formats': [
2020 |                 '%Y-%m-%d',
2021 |                 '%Y-%m-%d %H:%M:%S',
2022 |                 '%Y-%m-%d %H:%M:%S.%f',
2023 |             ]
2024 |         }
2025 | 
2026 |     def python_value(self, value):
2027 |         if isinstance(value, basestring):
2028 |             pp = lambda x: x.date()
2029 |             return format_date_time(value, self.attributes['formats'], pp)
2030 |         elif isinstance(value, datetime.datetime):
2031 |             return value.date()
2032 |         return value
2033 | 
2034 | 
2035 | class TimeColumn(Column):
2036 |     db_field = 'time'
2037 | 
2038 |     def get_attributes(self):
2039 |         return {
2040 |             'formats': [
2041 |                 '%H:%M:%S.%f',
2042 |                 '%H:%M:%S',
2043 |                 '%H:%M',
2044 |                 '%Y-%m-%d %H:%M:%S.%f',
2045 |                 '%Y-%m-%d %H:%M:%S',
2046 |             ]
2047 |         }
2048 | 
2049 |     def python_value(self, value):
2050 |         if isinstance(value, basestring):
2051 |             pp = lambda x: x.time()
2052 |             return format_date_time(value, self.attributes['formats'], pp)
2053 |         elif isinstance(value, datetime.datetime):
2054 |             return value.time()
2055 |         return value
2056 | 
2057 | 
2058 | class IntegerColumn(Column):
2059 |     db_field = 'integer'
2060 | 
2061 |     def db_value(self, value):
2062 |         return value or 0
2063 | 
2064 |     def python_value(self, value):
2065 |         if value is not None:
2066 |             return int(value)
2067 | 
2068 | 
2069 | class BigIntegerColumn(IntegerColumn):
2070 |     db_field = 'bigint'
2071 | 
2072 | 
2073 | class BooleanColumn(Column):
2074 |     db_field = 'boolean'
2075 | 
2076 |     def db_value(self, value):
2077 |         return bool(value)
2078 | 
2079 |     def python_value(self, value):
2080 |         return bool(value)
2081 | 
2082 | 
2083 | class FloatColumn(Column):
2084 |     db_field = 'float'
2085 | 
2086 |     def db_value(self, value):
2087 |         return value or 0.0
2088 | 
2089 |     def python_value(self, value):
2090 |         if value is not None:
2091 |             return float(value)
2092 | 
2093 | 
2094 | class DoubleColumn(FloatColumn):
2095 |     db_field = 'double'
2096 | 
2097 | 
2098 | class DecimalColumn(Column):
2099 |     db_field = 'decimal'
2100 |     template = '%(column_type)s(%(max_digits)d, %(decimal_places)d)'
2101 | 
2102 |     def get_attributes(self):
2103 |         return {
2104 |             'max_digits': 10,
2105 |             'decimal_places': 5,
2106 |         }
2107 | 
2108 |     def db_value(self, value):
2109 |         return value or decimal.Decimal(0)
2110 | 
2111 |     def python_value(self, value):
2112 |         if value is not None:
2113 |             if isinstance(value, decimal.Decimal):
2114 |                 return value
2115 |             return decimal.Decimal(str(value))
2116 | 
2117 | 
2118 | class PrimaryKeyColumn(Column):
2119 |     db_field = 'primary_key'
2120 | 
2121 | class PrimaryKeySequenceColumn(PrimaryKeyColumn):
2122 |     db_field = 'primary_key_with_sequence'
2123 | 
2124 | 
2125 | class FieldDescriptor(object):
2126 |     def __init__(self, field):
2127 |         self.field = field
2128 |         self._cache_name = '__%s' % self.field.name
2129 | 
2130 |     def __get__(self, instance, instance_type=None):
2131 |         if instance:
2132 |             return getattr(instance, self._cache_name, None)
2133 |         return self.field
2134 | 
2135 |     def __set__(self, instance, value):
2136 |         setattr(instance, self._cache_name, value)
2137 | 
2138 | 
2139 | class Field(object):
2140 |     column_class = None
2141 |     default = None
2142 |     field_template = "%(column)s%(nullable)s"
2143 |     _field_counter = 0
2144 |     _order = 0
2145 | 
2146 |     def __init__(self, null=False, db_index=False, unique=False, verbose_name=None,
2147 |                  help_text=None, db_column=None, default=None, *args, **kwargs):
2148 |         self.null = null
2149 |         self.db_index = db_index
2150 |         self.unique = unique
2151 |         self.verbose_name = verbose_name
2152 |         self.help_text = help_text
2153 |         self.db_column = db_column
2154 |         self.default = default
2155 | 
2156 |         self.attributes = kwargs
2157 | 
2158 |         Field._field_counter += 1
2159 |         self._order = Field._field_counter
2160 | 
2161 |     def add_to_class(self, klass, name):
2162 |         self.name = name
2163 |         self.model = klass
2164 |         self.verbose_name = self.verbose_name or re.sub('_+', ' ', name).title()
2165 |         self.db_column = self.db_column or self.name
2166 |         self.column = self.get_column()
2167 | 
2168 |         setattr(klass, name, FieldDescriptor(self))
2169 | 
2170 |     def get_column(self):
2171 |         return self.column_class(**self.attributes)
2172 | 
2173 |     def render_field_template(self):
2174 |         params = {
2175 |             'column': self.column.render(self.model._meta.database),
2176 |             'nullable': ternary(self.null, '', ' NOT NULL'),
2177 |         }
2178 |         params.update(self.column.attributes)
2179 |         return self.field_template % params
2180 | 
2181 |     def db_value(self, value):
2182 |         if (self.null and value is None):
2183 |             return None
2184 |         return self.column.db_value(value)
2185 | 
2186 |     def python_value(self, value):
2187 |         return self.column.python_value(value)
2188 | 
2189 |     def lookup_value(self, lookup_type, value):
2190 |         return self.db_value(value)
2191 | 
2192 |     def class_prepared(self):
2193 |         pass
2194 | 
2195 | 
2196 | class CharField(Field):
2197 |     column_class = VarCharColumn
2198 | 
2199 | 
2200 | class TextField(Field):
2201 |     column_class = TextColumn
2202 | 
2203 | 
2204 | class DateTimeField(Field):
2205 |     column_class = DateTimeColumn
2206 | 
2207 | 
2208 | class DateField(Field):
2209 |     column_class = DateColumn
2210 | 
2211 | 
2212 | class TimeField(Field):
2213 |     column_class = TimeColumn
2214 | 
2215 | 
2216 | class IntegerField(Field):
2217 |     column_class = IntegerColumn
2218 | 
2219 | 
2220 | class BigIntegerField(IntegerField):
2221 |     column_class = BigIntegerColumn
2222 | 
2223 | 
2224 | class BooleanField(IntegerField):
2225 |     column_class = BooleanColumn
2226 | 
2227 | 
2228 | class FloatField(Field):
2229 |     column_class = FloatColumn
2230 | 
2231 | 
2232 | class DoubleField(Field):
2233 |     column_class = DoubleColumn
2234 | 
2235 | 
2236 | class DecimalField(Field):
2237 |     column_class = DecimalColumn
2238 | 
2239 | 
2240 | class PrimaryKeyField(IntegerField):
2241 |     column_class = PrimaryKeyColumn
2242 |     field_template = "%(column)s NOT NULL PRIMARY KEY%(nextval)s"
2243 | 
2244 |     def __init__(self, column_class=None, *args, **kwargs):
2245 |         if kwargs.get('null'):
2246 |             raise ValueError('Primary keys cannot be nullable')
2247 |         if column_class:
2248 |             self.column_class = column_class
2249 |         if 'nextval' not in kwargs:
2250 |             kwargs['nextval'] = ''
2251 |         super(PrimaryKeyField, self).__init__(*args, **kwargs)
2252 | 
2253 |     def get_column_class(self):
2254 |         # check to see if we're using the default pk column
2255 |         if self.column_class == PrimaryKeyColumn:
2256 |             # if we have a sequence and can support them, then use the special
2257 |             # column class that supports sequences
2258 |             if self.model._meta.pk_sequence != None and self.model._meta.database.adapter.sequence_support:
2259 |                 self.column_class = PrimaryKeySequenceColumn
2260 |         return self.column_class
2261 | 
2262 |     def get_column(self):
2263 |         return self.get_column_class()(**self.attributes)
2264 | 
2265 | 
2266 | class ForeignRelatedObject(object):
2267 |     def __init__(self, to, field):
2268 |         self.to = to
2269 |         self.field = field
2270 |         self.field_name = self.field.name
2271 |         self.field_column = self.field.id_storage
2272 |         self.cache_name = '_cache_%s' % self.field_name
2273 | 
2274 |     def __get__(self, instance, instance_type=None):
2275 |         if not instance:
2276 |             return self.field
2277 | 
2278 |         if not getattr(instance, self.cache_name, None):
2279 |             id = getattr(instance, self.field_column, 0)
2280 |             qr = self.to.select().where(**{self.to._meta.pk_name: id})
2281 |             try:
2282 |                 setattr(instance, self.cache_name, qr.get())
2283 |             except self.to.DoesNotExist:
2284 |                 if not self.field.null:
2285 |                     raise
2286 |         return getattr(instance, self.cache_name, None)
2287 | 
2288 |     def __set__(self, instance, obj):
2289 |         if self.field.null and obj is None:
2290 |             setattr(instance, self.field_column, None)
2291 |             setattr(instance, self.cache_name, None)
2292 |         else:
2293 |             if not isinstance(obj, Model):
2294 |                 setattr(instance, self.field_column, obj)
2295 |             else:
2296 |                 assert isinstance(obj, self.to), "Cannot assign %s to %s, invalid type" % (obj, self.field.name)
2297 |                 setattr(instance, self.field_column, obj.get_pk())
2298 |                 setattr(instance, self.cache_name, obj)
2299 | 
2300 | 
2301 | class ReverseForeignRelatedObject(object):
2302 |     def __init__(self, related_model, name):
2303 |         self.field_name = name
2304 |         self.related_model = related_model
2305 | 
2306 |     def __get__(self, instance, instance_type=None):
2307 |         query = {self.field_name: instance.get_pk()}
2308 |         qr = self.related_model.select().where(**query)
2309 |         return qr
2310 | 
2311 | 
2312 | class ForeignKeyField(IntegerField):
2313 |     field_template = '%(column)s%(nullable)s REFERENCES %(to_table)s (%(to_pk)s)%(cascade)s%(extra)s'
2314 | 
2315 |     def __init__(self, to, null=False, related_name=None, cascade=False, extra=None, *args, **kwargs):
2316 |         self.to = to
2317 |         self._related_name = related_name
2318 |         self.cascade = cascade
2319 |         self.extra = extra
2320 | 
2321 |         kwargs.update({
2322 |             'cascade': ' ON DELETE CASCADE' if self.cascade else '',
2323 |             'extra': self.extra or '',
2324 |         })
2325 |         super(ForeignKeyField, self).__init__(null=null, *args, **kwargs)
2326 | 
2327 |     def add_to_class(self, klass, name):
2328 |         self.name = name
2329 |         self.model = klass
2330 |         self.db_column = self.db_column or self.name + '_id'
2331 | 
2332 |         if self.name == self.db_column:
2333 |             self.id_storage = self.db_column + '_id'
2334 |         else:
2335 |             self.id_storage = self.db_column
2336 | 
2337 |         if self.to == 'self':
2338 |             self.to = self.model
2339 | 
2340 |         self.verbose_name = self.verbose_name or re.sub('_', ' ', name).title()
2341 | 
2342 |         if self._related_name is not None:
2343 |             self.related_name = self._related_name
2344 |         else:
2345 |             self.related_name = klass._meta.db_table + '_set'
2346 | 
2347 |         klass._meta.rel_fields[name] = self.name
2348 |         setattr(klass, self.name, ForeignRelatedObject(self.to, self))
2349 |         setattr(klass, self.id_storage, None)
2350 | 
2351 |         reverse_rel = ReverseForeignRelatedObject(klass, self.name)
2352 |         setattr(self.to, self.related_name, reverse_rel)
2353 |         self.to._meta.reverse_relations[self.related_name] = klass
2354 | 
2355 |     def lookup_value(self, lookup_type, value):
2356 |         if isinstance(value, Model):
2357 |             return value.get_pk()
2358 |         return value or None
2359 | 
2360 |     def db_value(self, value):
2361 |         if isinstance(value, Model):
2362 |             return value.get_pk()
2363 |         if self.null and value is None:
2364 |             return None
2365 |         return self.column.db_value(value)
2366 | 
2367 |     def get_column(self):
2368 |         to_pk = self.to._meta.get_field_by_name(self.to._meta.pk_name)
2369 |         to_col_class = to_pk.get_column_class()
2370 |         if to_col_class not in (PrimaryKeyColumn, PrimaryKeySequenceColumn):
2371 |             self.column_class = to_pk.get_column_class()
2372 |         return self.column_class(**self.attributes)
2373 | 
2374 |     def class_prepared(self):
2375 |         # unfortunately because we may not know the primary key field
2376 |         # at the time this field's add_to_class() method is called, we
2377 |         # need to update the attributes after the class has been built
2378 |         self.attributes.update({
2379 |             'to_table': self.to._meta.db_table,
2380 |             'to_pk': self.to._meta.pk_col,
2381 |         })
2382 |         self.column = self.get_column()
2383 | 
2384 | 
2385 | # define a default database object in the module scope
2386 | database = SqliteDatabase(DATABASE_NAME)
2387 | 
2388 | 
2389 | class BaseModelOptions(object):
2390 |     ordering = None
2391 |     pk_sequence = None
2392 | 
2393 |     def __init__(self, model_class, options=None):
2394 |         # configurable options
2395 |         options = options or {'database': database}
2396 |         for k, v in options.items():
2397 |             setattr(self, k, v)
2398 | 
2399 |         self.rel_fields = {}
2400 |         self.reverse_relations = {}
2401 |         self.fields = {}
2402 |         self.columns = {}
2403 |         self.model_class = model_class
2404 | 
2405 |     def get_sorted_fields(self):
2406 |         return sorted(self.fields.items(), key=lambda (k,v): (k == self.pk_name and 1 or 2, v._order))
2407 | 
2408 |     def get_field_names(self):
2409 |         return [f[0] for f in self.get_sorted_fields()]
2410 | 
2411 |     def get_fields(self):
2412 |         return [f[1] for f in self.get_sorted_fields()]
2413 | 
2414 |     def get_field_by_name(self, name):
2415 |         if name in self.fields:
2416 |             return self.fields[name]
2417 |         raise AttributeError('Field named %s not found' % name)
2418 | 
2419 |     def get_column_names(self):
2420 |         return self.columns.keys()
2421 | 
2422 |     def get_column(self, field_or_col):
2423 |         if field_or_col in self.fields:
2424 |             return self.fields[field_or_col].db_column
2425 |         return field_or_col
2426 | 
2427 |     def get_related_field_by_name(self, name):
2428 |         if name in self.rel_fields:
2429 |             return self.fields[self.rel_fields[name]]
2430 | 
2431 |     def get_related_field_for_model(self, model, name=None):
2432 |         for field in self.fields.values():
2433 |             if isinstance(field, ForeignKeyField) and field.to == model:
2434 |                 if name is None or name == field.name or name == field.db_column:
2435 |                     return field
2436 | 
2437 |     def get_reverse_related_field_for_model(self, model, name=None):
2438 |         for field in model._meta.fields.values():
2439 |             if isinstance(field, ForeignKeyField) and field.to == self.model_class:
2440 |                 if name is None or name == field.name or name == field.db_column:
2441 |                     return field
2442 | 
2443 |     def get_field_for_related_name(self, model, related_name):
2444 |         for field in model._meta.fields.values():
2445 |             if isinstance(field, ForeignKeyField) and field.to == self.model_class:
2446 |                 if field.related_name == related_name:
2447 |                     return field
2448 | 
2449 |     def rel_exists(self, model):
2450 |         return self.get_related_field_for_model(model) or \
2451 |                self.get_reverse_related_field_for_model(model)
2452 | 
2453 | 
2454 | class BaseModel(type):
2455 |     inheritable_options = ['database', 'ordering', 'pk_sequence']
2456 | 
2457 |     def __new__(cls, name, bases, attrs):
2458 |         cls = super(BaseModel, cls).__new__(cls, name, bases, attrs)
2459 | 
2460 |         if not bases:
2461 |             return cls
2462 | 
2463 |         attr_dict = {}
2464 |         meta = attrs.pop('Meta', None)
2465 |         if meta:
2466 |             attr_dict = meta.__dict__
2467 | 
2468 |         for b in bases:
2469 |             base_meta = getattr(b, '_meta', None)
2470 |             if not base_meta:
2471 |                 continue
2472 | 
2473 |             for (k, v) in base_meta.__dict__.items():
2474 |                 if k in cls.inheritable_options and k not in attr_dict:
2475 |                     attr_dict[k] = v
2476 |                 elif k == 'fields':
2477 |                     for field_name, field_obj in v.items():
2478 |                         if isinstance(field_obj, PrimaryKeyField):
2479 |                             continue
2480 |                         if field_name in cls.__dict__:
2481 |                             continue
2482 |                         field_copy = copy.deepcopy(field_obj)
2483 |                         setattr(cls, field_name, field_copy)
2484 | 
2485 |         _meta = BaseModelOptions(cls, attr_dict)
2486 | 
2487 |         if not hasattr(_meta, 'db_table'):
2488 |             _meta.db_table = re.sub('[^\w]+', '_', cls.__name__.lower())
2489 | 
2490 |         if _meta.db_table in _meta.database.adapter.reserved_tables:
2491 |             warnings.warn('Table for %s ("%s") is reserved, please override using Meta.db_table' % (
2492 |                 cls, _meta.db_table,
2493 |             ))
2494 | 
2495 |         setattr(cls, '_meta', _meta)
2496 | 
2497 |         _meta.pk_name = None
2498 | 
2499 |         for name, attr in cls.__dict__.items():
2500 |             if isinstance(attr, Field):
2501 |                 attr.add_to_class(cls, name)
2502 |                 _meta.fields[attr.name] = attr
2503 |                 _meta.columns[attr.db_column] = attr
2504 |                 if isinstance(attr, PrimaryKeyField):
2505 |                     _meta.pk_name = attr.name
2506 | 
2507 |         if _meta.pk_name is None:
2508 |             _meta.pk_name = 'id'
2509 |             pk = PrimaryKeyField()
2510 |             pk.add_to_class(cls, _meta.pk_name)
2511 |             _meta.fields[_meta.pk_name] = pk
2512 | 
2513 |         _meta.model_name = cls.__name__
2514 | 
2515 |         pk_field = _meta.fields[_meta.pk_name]
2516 |         pk_col = pk_field.column
2517 |         if _meta.pk_sequence and _meta.database.adapter.sequence_support:
2518 |             pk_col.attributes['nextval'] = " default nextval('%s')" % _meta.pk_sequence
2519 | 
2520 |         _meta.pk_col = pk_field.db_column
2521 |         _meta.auto_increment = isinstance(pk_col, PrimaryKeyColumn)
2522 | 
2523 |         for field in _meta.fields.values():
2524 |             field.class_prepared()
2525 | 
2526 |         if hasattr(cls, '__unicode__'):
2527 |             setattr(cls, '__repr__', lambda self: '<%s: %r>' % (
2528 |                 _meta.model_name, self.__unicode__()))
2529 | 
2530 |         exception_class = type('%sDoesNotExist' % _meta.model_name, (DoesNotExist,), {})
2531 |         cls.DoesNotExist = exception_class
2532 | 
2533 |         return cls
2534 | 
2535 | 
2536 | class Model(object):
2537 |     __metaclass__ = BaseModel
2538 | 
2539 |     def __init__(self, *args, **kwargs):
2540 |         self.initialize_defaults()
2541 | 
2542 |         for k, v in kwargs.items():
2543 |             setattr(self, k, v)
2544 | 
2545 |     def initialize_defaults(self):
2546 |         for field in self._meta.fields.values():
2547 |             if field.default is not None:
2548 |                 if callable(field.default):
2549 |                     field_value = field.default()
2550 |                 else:
2551 |                     field_value = field.default
2552 |                 setattr(self, field.name, field_value)
2553 | 
2554 |     def prepared(self):
2555 |         # this hook is called when the model has been populated from a db cursor
2556 |         pass
2557 | 
2558 |     def __eq__(self, other):
2559 |         return other.__class__ == self.__class__ and \
2560 |                self.get_pk() and \
2561 |                other.get_pk() == self.get_pk()
2562 | 
2563 |     def get_field_dict(self):
2564 |         field_dict = {}
2565 | 
2566 |         for field in self._meta.fields.values():
2567 |             if isinstance(field, ForeignKeyField):
2568 |                 field_dict[field.name] = getattr(self, field.id_storage)
2569 |             else:
2570 |                 field_dict[field.name] = getattr(self, field.name)
2571 | 
2572 |         return field_dict
2573 | 
2574 |     @classmethod
2575 |     def table_exists(cls):
2576 |         return cls._meta.db_table in cls._meta.database.get_tables()
2577 | 
2578 |     @classmethod
2579 |     def create_table(cls, fail_silently=False, extra=''):
2580 |         if fail_silently and cls.table_exists():
2581 |             return
2582 | 
2583 |         cls._meta.database.create_table(cls, extra=extra)
2584 | 
2585 |         for field_name, field_obj in cls._meta.fields.items():
2586 |             if isinstance(field_obj, ForeignKeyField):
2587 |                 cls._meta.database.create_foreign_key(cls, field_obj)
2588 |             elif field_obj.db_index or field_obj.unique:
2589 |                 cls._meta.database.create_index(cls, field_obj.name, field_obj.unique)
2590 | 
2591 |     @classmethod
2592 |     def drop_table(cls, fail_silently=False):
2593 |         cls._meta.database.drop_table(cls, fail_silently)
2594 | 
2595 |     @classmethod
2596 |     def filter(cls, *args, **kwargs):
2597 |         return filter_query(cls, *args, **kwargs)
2598 | 
2599 |     @classmethod
2600 |     def select(cls, query=None):
2601 |         select_query = SelectQuery(cls, query)
2602 |         if cls._meta.ordering:
2603 |             select_query = select_query.order_by(*cls._meta.ordering)
2604 |         return select_query
2605 | 
2606 |     @classmethod
2607 |     def update(cls, **query):
2608 |         return UpdateQuery(cls, **query)
2609 | 
2610 |     @classmethod
2611 |     def insert(cls, **query):
2612 |         return InsertQuery(cls, **query)
2613 | 
2614 |     @classmethod
2615 |     def delete(cls, **query):
2616 |         return DeleteQuery(cls, **query)
2617 | 
2618 |     @classmethod
2619 |     def raw(cls, sql, *params):
2620 |         return RawQuery(cls, sql, *params)
2621 | 
2622 |     @classmethod
2623 |     def create(cls, **query):
2624 |         inst = cls(**query)
2625 |         inst.save(force_insert=True)
2626 |         return inst
2627 | 
2628 |     @classmethod
2629 |     def get_or_create(cls, **query):
2630 |         try:
2631 |             inst = cls.get(**query)
2632 |         except cls.DoesNotExist:
2633 |             inst = cls.create(**query)
2634 |         return inst
2635 | 
2636 |     @classmethod
2637 |     def get(cls, *args, **kwargs):
2638 |         return cls.select().get(*args, **kwargs)
2639 | 
2640 |     def get_pk(self):
2641 |         return getattr(self, self._meta.pk_name, None)
2642 | 
2643 |     def set_pk(self, pk):
2644 |         pk_field = self._meta.fields[self._meta.pk_name]
2645 |         setattr(self, self._meta.pk_name, pk_field.python_value(pk))
2646 | 
2647 |     def save(self, force_insert=False):
2648 |         field_dict = self.get_field_dict()
2649 |         if self.get_pk() and not force_insert:
2650 |             field_dict.pop(self._meta.pk_name)
2651 |             update = self.update(
2652 |                 **field_dict
2653 |             ).where(**{self._meta.pk_name: self.get_pk()})
2654 |             update.execute()
2655 |         else:
2656 |             if self._meta.auto_increment:
2657 |                 field_dict.pop(self._meta.pk_name)
2658 |             insert = self.insert(**field_dict)
2659 |             new_pk = insert.execute()
2660 |             if self._meta.auto_increment:
2661 |                 setattr(self, self._meta.pk_name, new_pk)
2662 | 
2663 |     @classmethod
2664 |     def collect_models(cls, accum=None):
2665 |         # dfs to grab any affected models, then from the bottom up issue
2666 |         # proper deletes using subqueries to obtain objects to remove
2667 |         accum = accum or []
2668 |         models = []
2669 | 
2670 |         for related_name, rel_model in cls._meta.reverse_relations.items():
2671 |             rel_field = cls._meta.get_field_for_related_name(rel_model, related_name)
2672 |             coll = [(rel_model, rel_field.name, rel_field.null)] + accum
2673 |             if not rel_field.null:
2674 |                 models.extend(rel_model.collect_models(coll))
2675 | 
2676 |             models.append(coll)
2677 |         return models
2678 | 
2679 |     def collect_queries(self):
2680 |         select_queries = []
2681 |         nullable_queries = []
2682 |         collected_models = self.collect_models()
2683 |         if collected_models:
2684 |             for model_joins in collected_models:
2685 |                 depth = len(model_joins)
2686 |                 base, last, nullable = model_joins[0]
2687 |                 query = base.select([base._meta.pk_name])
2688 |                 for model, join, _ in model_joins[1:]:
2689 |                     query = query.join(model, on=last)
2690 |                     last = join
2691 | 
2692 |                 query = query.where(**{last: self.get_pk()})
2693 |                 if nullable:
2694 |                     nullable_queries.append((query, last, depth))
2695 |                 else:
2696 |                     select_queries.append((query, last, depth))
2697 |         return select_queries, nullable_queries
2698 | 
2699 |     def delete_instance(self, recursive=False):
2700 |         # XXX: it is strongly recommended you run this in a transaction if using
2701 |         # the recursive delete
2702 |         if recursive:
2703 |             # reverse relations, i.e. anything that would be orphaned, delete.
2704 |             select_queries, nullable_queries = self.collect_queries()
2705 | 
2706 |             # currently doesn't work with mysql:
2707 |             # http://dev.mysql.com/doc/refman/5.1/en/subquery-restrictions.html
2708 |             for query, fk_field, depth in select_queries:
2709 |                 model = query.model
2710 |                 if not self._meta.database.adapter.subquery_delete_same_table:
2711 |                     query = [obj.get_pk() for obj in query]
2712 |                     if not query:
2713 |                         continue
2714 |                 model.delete().where(**{
2715 |                     '%s__in' % model._meta.pk_name: query,
2716 |                 }).execute()
2717 |             for query, fk_field, depth in nullable_queries:
2718 |                 model = query.model
2719 |                 if not self._meta.database.adapter.subquery_delete_same_table:
2720 |                     query = [obj.get_pk() for obj in query]
2721 |                     if not query:
2722 |                         continue
2723 |                 model.update(**{fk_field: None}).where(**{
2724 |                     '%s__in' % model._meta.pk_name: query,
2725 |                 }).execute()
2726 | 
2727 |         return self.delete().where(**{
2728 |             self._meta.pk_name: self.get_pk()
2729 |         }).execute()
2730 | 
2731 |     def refresh(self, *fields):
2732 |         fields = fields or self._meta.get_field_names()
2733 |         obj = self.select(fields).get(**{self._meta.pk_name: self.get_pk()})
2734 | 
2735 |         for field_name in fields:
2736 |             setattr(self, field_name, getattr(obj, field_name))
2737 | 
2738 | def find_subclasses(klass, include_self=False):
2739 |     accum = []
2740 |     for child in klass.__subclasses__():
2741 |         accum.extend(find_subclasses(child, True))
2742 |     if include_self:
2743 |         accum.append(klass)
2744 |     return accum
2745 | 
2746 | def create_model_tables(models, **create_table_kwargs):
2747 |     """Create tables for all given models (in the right order)."""
2748 |     for m in sort_models_topologically(models):
2749 |         m.create_table(**create_table_kwargs)
2750 | 
2751 | def drop_model_tables(models, **drop_table_kwargs):
2752 |     """Drop tables for all given models (in the right order)."""
2753 |     for m in reversed(sort_models_topologically(models)):
2754 |         m.drop_table(**drop_table_kwargs)
2755 | 
2756 | def sort_models_topologically(models):
2757 |     """Sort models topologically so that parents will precede children."""
2758 |     models = set(models)
2759 |     seen = set()
2760 |     ordering = []
2761 |     def dfs(model):
2762 |         if model in models and model not in seen:
2763 |             seen.add(model)
2764 |             for child_model in model._meta.reverse_relations.values():
2765 |                 dfs(child_model)
2766 |             ordering.append(model)  # parent will follow descendants
2767 |     # order models by name and table initially to guarantee a total ordering
2768 |     names = lambda m: (m._meta.model_name, m._meta.db_table)
2769 |     for m in sorted(models, key=names, reverse=True):
2770 |         dfs(m)
2771 |     return list(reversed(ordering))  # want parents first in output ordering
2772 | 


--------------------------------------------------------------------------------