← Back to branch summary

~aaron-whitehouse/duplicity/bug_884371_asterisks_in_includes

« back to all changes in this revision

Viewing changes to duplicity/file_naming.py

  • Committer: Kenneth Loafman
  • Date: 2015-01-22 20:04:16 UTC
  • Revision ID: kenneth@loafman.com-20150122200416-k2byfc7hisdklvr3
* Misc fixes for the following PEP8 issues:
  - E127, E128
  - see http://pep8.readthedocs.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
duplicity/file_naming.py
57
57
        return
58
58
 
59
59
    full_vol_re = re.compile("^" + globals.file_prefix + globals.file_prefix_archive + "duplicity-full"
60
 
                         "\\.(?P<time>.*?)"
61
 
                         "\\.vol(?P<num>[0-9]+)"
62
 
                         "\\.difftar"
63
 
                         "(?P<partial>(\\.part))?"
64
 
                         "($|\\.)")
 
60
                             "\\.(?P<time>.*?)"
 
61
                             "\\.vol(?P<num>[0-9]+)"
 
62
                             "\\.difftar"
 
63
                             "(?P<partial>(\\.part))?"
 
64
                             "($|\\.)")
65
65
 
66
66
    full_vol_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_archive + "df"
67
 
                               "\\.(?P<time>[0-9a-z]+?)"
68
 
                               "\\.(?P<num>[0-9a-z]+)"
69
 
                               "\\.dt"
70
 
                               "(?P<partial>(\\.p))?"
71
 
                               "($|\\.)")
 
67
                                   "\\.(?P<time>[0-9a-z]+?)"
 
68
                                   "\\.(?P<num>[0-9a-z]+)"
 
69
                                   "\\.dt"
 
70
                                   "(?P<partial>(\\.p))?"
 
71
                                   "($|\\.)")
72
72
 
73
73
    full_manifest_re = re.compile("^" + globals.file_prefix + globals.file_prefix_manifest + "duplicity-full"
74
 
                              "\\.(?P<time>.*?)"
75
 
                              "\\.manifest"
76
 
                              "(?P<partial>(\\.part))?"
77
 
                              "($|\\.)")
 
74
                                  "\\.(?P<time>.*?)"
 
75
                                  "\\.manifest"
 
76
                                  "(?P<partial>(\\.part))?"
 
77
                                  "($|\\.)")
78
78
 
79
79
    full_manifest_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_manifest + "df"
80
 
                                    "\\.(?P<time>[0-9a-z]+?)"
81
 
                                    "\\.m"
82
 
                                    "(?P<partial>(\\.p))?"
83
 
                                    "($|\\.)")
 
80
                                        "\\.(?P<time>[0-9a-z]+?)"
 
81
                                        "\\.m"
 
82
                                        "(?P<partial>(\\.p))?"
 
83
                                        "($|\\.)")
84
84
 
85
85
    inc_vol_re = re.compile("^" + globals.file_prefix + globals.file_prefix_archive + "duplicity-inc"
86
 
                        "\\.(?P<start_time>.*?)"
87
 
                        "\\.to\\.(?P<end_time>.*?)"
88
 
                        "\\.vol(?P<num>[0-9]+)"
89
 
                        "\\.difftar"
90
 
                        "($|\\.)")
 
86
                            "\\.(?P<start_time>.*?)"
 
87
                            "\\.to\\.(?P<end_time>.*?)"
 
88
                            "\\.vol(?P<num>[0-9]+)"
 
89
                            "\\.difftar"
 
90
                            "($|\\.)")
91
91
 
92
92
    inc_vol_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_archive + "di"
93
 
                              "\\.(?P<start_time>[0-9a-z]+?)"
94
 
                              "\\.(?P<end_time>[0-9a-z]+?)"
95
 
                              "\\.(?P<num>[0-9a-z]+)"
96
 
                              "\\.dt"
97
 
                              "($|\\.)")
 
93
                                  "\\.(?P<start_time>[0-9a-z]+?)"
 
94
                                  "\\.(?P<end_time>[0-9a-z]+?)"
 
95
                                  "\\.(?P<num>[0-9a-z]+)"
 
96
                                  "\\.dt"
 
97
                                  "($|\\.)")
98
98
 
99
99
    inc_manifest_re = re.compile("^" + globals.file_prefix + globals.file_prefix_manifest + "duplicity-inc"
100
 
                             "\\.(?P<start_time>.*?)"
101
 
                             "\\.to"
102
 
                             "\\.(?P<end_time>.*?)"
103
 
                             "\\.manifest"
104
 
                             "(?P<partial>(\\.part))?"
105
 
                             "(\\.|$)")
 
100
                                 "\\.(?P<start_time>.*?)"
 
101
                                 "\\.to"
 
102
                                 "\\.(?P<end_time>.*?)"
 
103
                                 "\\.manifest"
 
104
                                 "(?P<partial>(\\.part))?"
 
105
                                 "(\\.|$)")
106
106
 
107
107
    inc_manifest_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_manifest + "di"
108
 
                                   "\\.(?P<start_time>[0-9a-z]+?)"
109
 
                                   "\\.(?P<end_time>[0-9a-z]+?)"
110
 
                                   "\\.m"
111
 
                                   "(?P<partial>(\\.p))?"
112
 
                                   "(\\.|$)")
 
108
                                       "\\.(?P<start_time>[0-9a-z]+?)"
 
109
                                       "\\.(?P<end_time>[0-9a-z]+?)"
 
110
                                       "\\.m"
 
111
                                       "(?P<partial>(\\.p))?"
 
112
                                       "(\\.|$)")
113
113
 
114
114
    full_sig_re = re.compile("^" + globals.file_prefix + globals.file_prefix_signature + "duplicity-full-signatures"
115
 
                         "\\.(?P<time>.*?)"
116
 
                         "\\.sigtar"
117
 
                         "(?P<partial>(\\.part))?"
118
 
                         "(\\.|$)")
 
115
                             "\\.(?P<time>.*?)"
 
116
                             "\\.sigtar"
 
117
                             "(?P<partial>(\\.part))?"
 
118
                             "(\\.|$)")
119
119
 
120
120
    full_sig_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_signature + "dfs"
121
 
                               "\\.(?P<time>[0-9a-z]+?)"
122
 
                               "\\.st"
123
 
                               "(?P<partial>(\\.p))?"
124
 
                               "(\\.|$)")
 
121
                                   "\\.(?P<time>[0-9a-z]+?)"
 
122
                                   "\\.st"
 
123
                                   "(?P<partial>(\\.p))?"
 
124
                                   "(\\.|$)")
125
125
 
126
126
    new_sig_re = re.compile("^" + globals.file_prefix + globals.file_prefix_signature + "duplicity-new-signatures"
127
 
                        "\\.(?P<start_time>.*?)"
128
 
                        "\\.to"
129
 
                        "\\.(?P<end_time>.*?)"
130
 
                        "\\.sigtar"
131
 
                        "(?P<partial>(\\.part))?"
132
 
                        "(\\.|$)")
 
127
                            "\\.(?P<start_time>.*?)"
 
128
                            "\\.to"
 
129
                            "\\.(?P<end_time>.*?)"
 
130
                            "\\.sigtar"
 
131
                            "(?P<partial>(\\.part))?"
 
132
                            "(\\.|$)")
133
133
 
134
134
    new_sig_re_short = re.compile("^" + globals.file_prefix + globals.file_prefix_signature + "dns"
135
 
                              "\\.(?P<start_time>[0-9a-z]+?)"
136
 
                              "\\.(?P<end_time>[0-9a-z]+?)"
137
 
                              "\\.st"
138
 
                              "(?P<partial>(\\.p))?"
139
 
                              "(\\.|$)")
 
135
                                  "\\.(?P<start_time>[0-9a-z]+?)"
 
136
                                  "\\.(?P<end_time>[0-9a-z]+?)"
 
137
                                  "\\.st"
 
138
                                  "(?P<partial>(\\.p))?"
 
139
                                  "(\\.|$)")
140
140
 
141
141
 
142
142
def to_base36(n):
219
219
        assert not (volume_number and part_string)
220
220
        if type == "full-sig":
221
221
            if globals.short_filenames:
222
 
                return (globals.file_prefix + globals.file_prefix_signature + "dfs.%s.st%s%s" % 
 
222
                return (globals.file_prefix + globals.file_prefix_signature + "dfs.%s.st%s%s" %
223
223
                        (to_base36(dup_time.curtime), part_string, suffix))
224
224
            else:
225
 
                return (globals.file_prefix + globals.file_prefix_signature + "duplicity-full-signatures.%s.sigtar%s%s" % 
 
225
                return (globals.file_prefix + globals.file_prefix_signature + "duplicity-full-signatures.%s.sigtar%s%s" %
226
226
                        (dup_time.curtimestr, part_string, suffix))
227
227
        elif type == "new-sig":
228
228
            if globals.short_filenames:
229
 
                return (globals.file_prefix + globals.file_prefix_signature + "dns.%s.%s.st%s%s" % 
 
229
                return (globals.file_prefix + globals.file_prefix_signature + "dns.%s.%s.st%s%s" %
230
230
                        (to_base36(dup_time.prevtime), to_base36(dup_time.curtime),
231
231
                         part_string, suffix))
232
232
            else:
233
 
                return (globals.file_prefix + globals.file_prefix_signature + "duplicity-new-signatures.%s.to.%s.sigtar%s%s" % 
 
233
                return (globals.file_prefix + globals.file_prefix_signature + "duplicity-new-signatures.%s.to.%s.sigtar%s%s" %
234
234
                        (dup_time.prevtimestr, dup_time.curtimestr,
235
235
                         part_string, suffix))
236
236
    else:
237
237
        assert volume_number or manifest
238
238
        assert not (volume_number and manifest)
239
 
            
 
239
 
240
240
        prefix = globals.file_prefix
241
 
        
 
241
 
242
242
        if volume_number:
243
243
            if globals.short_filenames:
244
244
                vol_string = "%s.dt" % to_base36(volume_number)
251
251
            else:
252
252
                vol_string = "manifest"
253
253
            prefix += globals.file_prefix_manifest
254
 
            
 
254
 
255
255
        if type == "full":
256
256
            if globals.short_filenames:
257
257
                return ("%sdf.%s.%s%s%s" % (prefix, to_base36(dup_time.curtime),
258
 
                                          vol_string, part_string, suffix))
 
258
                                            vol_string, part_string, suffix))
259
259
            else:
260
260
                return ("%sduplicity-full.%s.%s%s%s" % (prefix, dup_time.curtimestr,
261
 
                                                      vol_string, part_string, suffix))
 
261
                                                        vol_string, part_string, suffix))
262
262
        elif type == "inc":
263
263
            if globals.short_filenames:
264
264
                return ("%sdi.%s.%s.%s%s%s" % (prefix, to_base36(dup_time.prevtime),
265
 
                                             to_base36(dup_time.curtime),
266
 
                                             vol_string, part_string, suffix))
 
265
                                               to_base36(dup_time.curtime),
 
266
                                               vol_string, part_string, suffix))
267
267
            else:
268
268
                return ("%sduplicity-inc.%s.to.%s.%s%s%s" % (prefix, dup_time.prevtimestr,
269
 
                                                           dup_time.curtimestr,
270
 
                                                           vol_string, part_string, suffix))
 
269
                                                             dup_time.curtimestr,
 
270
                                                             vol_string, part_string, suffix))
271
271
        else:
272
272
            assert 0
273
273