← Back to branch summary

~vorlon/ubuntu/saucy/gourmet/trunk

« back to all changes in this revision

Viewing changes to src/lib/exporters/__init__old.py

  • Committer: Bazaar Package Importer
  • Author(s): Rolf Leggewie
  • Date: 2008-07-26 13:29:41 UTC
  • Revision ID: james.westby@ubuntu.com-20080726132941-6ldd73qmacrzz0bn
Tags: upstream-0.14.0
Import upstream version 0.14.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/exporters/__init__old.py
 
1
import exporter, gxml_exporter, gxml2_exporter
 
2
import html_exporter, mealmaster_exporter, recipe_emailer
 
3
import pdf_exporter
 
4
#import eatdrinkfeelgood_exporter
 
5
import recipe_emailer
 
6
import printer
 
7
from gettext import gettext as _
 
8
from gourmet.gdebug import *
 
9
 
 
10
try:
 
11
    import rtf_exporter
 
12
    rtf = True
 
13
except ImportError:
 
14
    debug('No RTF support',0)
 
15
    rtf = False
 
16
 
 
17
# Filetypes as presented to user
 
18
WEBPAGE = _('HTML Web Page')
 
19
MMF = _('MealMaster file')
 
20
TXT = _('Plain Text')
 
21
RTF = _('RTF')
 
22
PDF = _('PDF (Portable Document Format)')
 
23
GXML2 = _('Gourmet XML File')
 
24
GXML = _('Gourmet XML File (Obsolete, < v.0.8.2)')
 
25
EDFG = _('Eat Drink Feel Good XML File')
 
26
 
 
27
# Our list of filename (for user), mimetype, extensions
 
28
# for each file we can save
 
29
saveas_filters = [
 
30
    [WEBPAGE,['text/html'],['']],
 
31
    [MMF,['text/mmf'],['*.mmf','*.MMF']],
 
32
    [TXT,['text/plain'],['*.txt','*.TXT']],      
 
33
    [GXML2,['text/xml'],['*.grmt','*.xml','*.XML']],
 
34
    [PDF,['application/pdf'],['*.pdf']],
 
35
    #[EDFG,['text/xml'],['*.xml','*.XML']],
 
36
    #[GXML,['text/xml'],['*.xml','*.XML']],
 
37
    ]
 
38
 
 
39
saveas_single_filters = [
 
40
    [WEBPAGE,['text/html'],['*.html','*.htm','*.HTM','*.HTML']],
 
41
    [MMF,['text/mmf'],['*.mmf','*.MMF']],
 
42
    [TXT,['text/plain'],['*.txt','*.TXT']],      
 
43
    #[GXML,['text/xml'],['*.xml','*.XML']],
 
44
    [GXML2,['text/xml'],['*.grmt','*.xml','*.XML']],
 
45
    [PDF,['application/pdf'],['*.pdf']],    
 
46
    #[EDFG,['text/xml'],['*.xml','*.XML']],
 
47
    ]
 
48
 
 
49
# Add RTF to our files if it's supported
 
50
if rtf:
 
51
    saveas_filters.append([RTF,['application/rtf','text/rtf'],['*.rtf','*.RTF']]),
 
52
    saveas_single_filters.append([RTF,['application/rtf','text/rtf'],['*.rtf','*.RTF']]),
 
53
 
 
54
# Our dictionary (keyed by filetype description string) of exporters.
 
55
# This works pretty magically: 'mult_exporter' and 'exporter' keys are lambdas
 
56
# that take a dictionary of standard arguments which we can use as we like
 
57
# {'rd':recipe_database,'rv':recipe_view,'file':outfile,'conv':converter_instance,
 
58
#  'prog':progress_displaying_function,'rec':individual_recipe_to_export,...}
 
59
exporter_dict = {
 
60
    WEBPAGE : {'mult_exporter': lambda args : html_exporter.website_exporter(
 
61
    args['rd'], 
 
62
    args['rv'],
 
63
    args['file'],
 
64
    args['conv'],
 
65
    progress_func=args['prog']),
 
66
               'exporter': lambda args : html_exporter.html_exporter(
 
67
    args['rd'],
 
68
    args['rec'],
 
69
    args['out'],
 
70
    change_units=args['change_units'],
 
71
    mult=args['mult'],
 
72
    conv=args['conv']),
 
73
               'label':_('Exporting Webpage'),
 
74
               'sublabel':_('Exporting recipes to HTML files in directory %(file)s'),
 
75
               'single_completed':_('Recipe saved as HTML file %(file)s'),
 
76
               }, # END WEBPAGE
 
77
    MMF : {'mult_exporter':lambda args : exporter.ExporterMultirec(
 
78
    args['rd'],
 
79
    args['rv'],
 
80
    args['file'],
 
81
    one_file=True,
 
82
    ext='mmf',
 
83
    conv=args['conv'],
 
84
    progress_func=args['prog'],
 
85
    exporter=mealmaster_exporter.mealmaster_exporter),
 
86
           'exporter': lambda args: mealmaster_exporter.mealmaster_exporter(args['rd'],
 
87
                                                                            args['rec'],
 
88
                                                                            args['out'],
 
89
                                                                            mult=args['mult'],
 
90
                                                                            change_units=args['change_units'],
 
91
                                                                            conv=args['conv']),
 
92
           'label':_('MealMaster Export'),
 
93
                                            'sublabel':_('Exporting recipes to MealMaster file %(file)s.'),
 
94
           'single_completed':_('Recipe saved as MealMaster file %(file)s'),
 
95
           },    # END MMF
 
96
    TXT : {'mult_exporter':lambda args: exporter.ExporterMultirec(
 
97
    args['rd'],args['rv'],args['file'],
 
98
    conv=args['conv'],
 
99
    progress_func=args['prog']),
 
100
           'exporter':lambda args: exporter.exporter_mult(args['rd'],
 
101
                                                          args['rec'],
 
102
                                                          args['out'],
 
103
                                                          mult=args['mult'],
 
104
                                                          change_units=args['change_units'],
 
105
                                                          conv=args['conv']),
 
106
           'label':_('Text Export'),
 
107
           'sublabel':_('Exporting recipes to Plain Text file %(file)s.'),
 
108
           'single_completed':_('Recipe saved as Plain Text file %(file)s'),
 
109
           },    # END TXT
 
110
    GXML2 : {'mult_exporter':lambda args: gxml2_exporter.recipe_table_to_xml(
 
111
    args['rd'],
 
112
    args['rv'],
 
113
    args['file'],
 
114
    progress_func=args['prog']),
 
115
             'exporter': lambda args: gxml2_exporter.recipe_table_to_xml(args['rd'],
 
116
                                                                  [args['rec']],
 
117
                                                                  args['out'],
 
118
                                                                  change_units=args['change_units'],
 
119
                                                                  mult=args['mult']
 
120
                                                                  ).run(),
 
121
             'label':_('Gourmet XML Export'),
 
122
             'sublabel':_('Exporting recipes to Gourmet XML file %(file)s.'),
 
123
             'single_completed':_('Recipe saved in Gourmet XML file %(file)s.'),
 
124
             },    # END GXML2
 
125
    RTF : {'mult_exporter':lambda args : rtf_exporter.rtf_exporter_multidoc(args['rd'],
 
126
                                                                            args['rv'],
 
127
                                                                            args['file'],
 
128
                                                                            progress_func=args['prog']),
 
129
           'exporter': lambda args: rtf_exporter.rtf_exporter(args['rd'],
 
130
                                                              args['rec'],
 
131
                                                              args['out'],
 
132
                                                              change_units=args['change_units'],
 
133
                                                              mult=args['mult']),
 
134
           'label':_('RTF Export'),
 
135
           'sublabel':_('Exporting recipes to Rich Text file %(file)s.'),
 
136
           'single_completed':_('Recipe saved as Rich Text file %(file)s'),
 
137
           'mode':'b'
 
138
           }, # END RTF
 
139
 
 
140
    PDF : {'mult_exporter':lambda args: pdf_exporter.PdfExporterMultiDoc(args['rd'],
 
141
                                                                         args['rv'],
 
142
                                                                         args['file'],
 
143
                                                                         progress_func=args['prog'],
 
144
                                                                         pdf_args=args['extra_prefs'],
 
145
                                                                         ),
 
146
           'exporter':lambda args: pdf_exporter.PdfExporter(args['rd'],
 
147
                                                            args['rec'],
 
148
                                                            args['out'],
 
149
                                                            change_units=args['change_units'],
 
150
                                                            mult=args['mult'],
 
151
                                                            pdf_args=args['extra_prefs'],
 
152
                                                            ),
 
153
           'label':_('PDF Export'),
 
154
           'sublabel':_('Exporting recipes to PDF %(file)s.'),
 
155
           'single_completed':_('Recipe saved as PDF %(file)s'),
 
156
           'extra_prefs_dialog':pdf_exporter.get_pdf_prefs,
 
157
           'mode':'b'           
 
158
           }, # END PDF
 
159
    
 
160
    # EDFG : {'mult_exporter': lambda args : eatdrinkfeelgood_exporter.EdfgXmlM(
 
161
#         args['rd'], 
 
162
#         args['rv'],
 
163
#         args['file'],
 
164
#         args['conv'],
 
165
#         progress_func=None),
 
166
#         'exporter': lambda args : eatdrinkfeelgood_exporter.EdfgXml(
 
167
#         args['rd'],
 
168
#         args['rec'],
 
169
#         args['out'],
 
170
#         change_units=args['change_units'],
 
171
#         mult=args['mult'],
 
172
#         conv=args['conv']),
 
173
#         'label':_('Exporting Eat Drink Feel Good Format'),
 
174
#         'sublabel':_('Exporting recipes to EDFG in directory %(file)s'),
 
175
#         'single_completed':_('Recipe saved as EDFG file %(file)s'),
 
176
#         },
 
177
    }
 
178
 
 
179
for name,mimetype,extensions in saveas_single_filters:
 
180
    exporter_dict[name]['single_extension']=extensions[0].strip('.*')
 
181
for name,mimetype,extensions in saveas_filters:
 
182
    exporter_dict[name]['multiple_extension']=extensions[0].strip('.*')
 
183
 
 
184
 
 
185
class Tester:
 
186
    def __init__ (self):
 
187
        import gourmet.recipeManager, gourmet.convert
 
188
        self.rm = gourmet.recipeManager.RecipeManager(**gourmet.recipeManager.dbargs)
 
189
        self.conv = gourmet.convert.Converter()
 
190
 
 
191
    def interactive_test (self):
 
192
        self.run_export(**self.get_choice())
 
193
 
 
194
    def get_choice (self):
 
195
        print 'We can export: '
 
196
        for n,f in enumerate(saveas_filters):
 
197
            print n,'. ',f
 
198
        n = raw_input('Choose format: ')
 
199
        while type(n)==str or n < 0 or n > len(saveas_filters):
 
200
            try:
 
201
                n=int(n)
 
202
            except:
 
203
                n = raw_input('Choose format (enter number of a choice please!): ')
 
204
        format=saveas_filters[n][0]
 
205
        fn = raw_input('Export %s to file: '%format)
 
206
        if raw_input('Multiple recipes? y or n [n]: ')=='y':
 
207
            mode='mult_exporter'
 
208
            out=None
 
209
        else:
 
210
            mode='exporter'
 
211
            out = open(fn,'wb')
 
212
        return {'file':fn,
 
213
                'format':format,
 
214
                'out':out,
 
215
                'mode':mode,
 
216
                }
 
217
 
 
218
    def run_export (self, **args):
 
219
        defaults = {'rd':self.rm,
 
220
                    'mult':1,
 
221
                    'rec':self.rm.recipe_table.select(deleted=False)[0],
 
222
                    'rv':self.rm.recipe_table.select(deleted=False),
 
223
                    'change_units':True,
 
224
                    'conv':self.conv,
 
225
                    'format': TXT,
 
226
                    'mode':'exporter',
 
227
                    'out':None
 
228
                    }
 
229
        for k,v in args.items(): defaults[k]=v
 
230
        exporter = exporter_dict[defaults['format']][defaults['mode']]
 
231
        print 'Running exporter ',exporter, defaults['format'], defaults['mode'], defaults['rec'].title, 
 
232
        e=exporter(defaults)
 
233
        if hasattr(e,'run'): e.run()
 
234
        if defaults['out']:
 
235
            defaults['out'].close()
 
236
            print 'Closed file'
 
237
 
 
238
if __name__ == '__main__':
 
239
    t=Tester()
 
240
    t.interactive_test()
 
241
 
 
242
            
 
243
            
 
244
            
 
245
            
 
246
            
 
247