← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/util.py

  • Committer: William Grant
  • Date: 2009-05-28 02:43:56 UTC
  • Revision ID: grantw@unimelb.edu.au-20090528024356-mlrhizz7omnr71hd
Test ivle.mimetypes.nice_filetype.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/util.py
 
1
# IVLE - Informatics Virtual Learning Environment
 
2
# Copyright (C) 2007-2008 The University of Melbourne
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
# Module: util
 
19
# Author: Matt Giuca
 
20
# Date: 12/12/2007
 
21
 
 
22
# Contains common utility functions.
 
23
 
 
24
import os
 
25
import sys
 
26
import stat
 
27
 
 
28
class IVLEError(Exception):
 
29
    """Legacy general IVLE exception.
 
30
 
 
31
    This is the old "standard" exception class for IVLE errors. It is only
 
32
    used in fileservice, and should not be used in any new code.
 
33
    """
 
34
    def __init__(self, httpcode, message=None):
 
35
        self.httpcode = httpcode
 
36
        self.message = message
 
37
        self.args = (httpcode, message)
 
38
 
 
39
class IVLEJailError(Exception):
 
40
    """Exception proxying an in-jail error.
 
41
 
 
42
    This exception indicates an error that occurred inside an IVLE CGI script
 
43
    inside the jail. It should never be raised directly - only by the 
 
44
    interpreter.
 
45
 
 
46
    Information will be retrieved from it, and then treated as a normal
 
47
    error.
 
48
    """
 
49
    def __init__(self, type_str, message, info):
 
50
        self.type_str = type_str
 
51
        self.message = message
 
52
        self.info = info
 
53
 
 
54
class FakeObject(object):
 
55
    """ A representation of an object that can't be Pickled """
 
56
    def __init__(self, type, name, attrib={}):
 
57
        self.type = type
 
58
        self.name = name
 
59
        self.attrib = attrib
 
60
 
 
61
    def __repr__(self):
 
62
        return "<Fake %s %s>"%(self.type, self.name)
 
63
 
 
64
def split_path(path):
 
65
    """Given a path, returns a tuple consisting of the top-level directory in
 
66
    the path, and the rest of the path. Note that both items in the tuple will
 
67
    NOT begin with a slash, regardless of whether the original path did. Also
 
68
    normalises the path.
 
69
 
 
70
    Always returns a pair of strings, except for one special case, in which
 
71
    the path is completely empty (or just a single slash). In this case the
 
72
    return value will be (None, ''). But still always returns a pair.
 
73
 
 
74
    Examples:
 
75
 
 
76
    >>> split_path("")
 
77
    (None, '')
 
78
    >>> split_path("/")
 
79
    (None, '')
 
80
    >>> split_path("home")
 
81
    ('home', '')
 
82
    >>> split_path("home/docs/files")
 
83
    ('home', 'docs/files')
 
84
    >>> split_path("//home/docs/files")
 
85
    ('', 'home/docs/files')
 
86
    """
 
87
    path = os.path.normpath(path)
 
88
    # Ignore the opening slash
 
89
    if path.startswith(os.sep):
 
90
        path = path[len(os.sep):]
 
91
    if path == '' or path == '.':
 
92
        return (None, '')
 
93
    splitpath = path.split(os.sep, 1)
 
94
    if len(splitpath) == 1:
 
95
        return (splitpath[0], '')
 
96
    else:
 
97
        return tuple(splitpath)
 
98
 
 
99
def relpath(path, start=os.path.curdir):
 
100
    """Return a relative version of a path.
 
101
    XXX Backported from Python 2.6 posixpath.py.
 
102
    """
 
103
 
 
104
    if not path:
 
105
        raise ValueError("no path specified")
 
106
 
 
107
    start_list = os.path.abspath(start).split(os.path.sep)
 
108
    path_list = os.path.abspath(path).split(os.path.sep)
 
109
 
 
110
    # Work out how much of the filepath is shared by start and path.
 
111
    i = len(os.path.commonprefix([start_list, path_list]))
 
112
 
 
113
    rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:]
 
114
    if not rel_list:
 
115
        return os.path.curdir
 
116
    return os.path.join(*rel_list)
 
117
 
 
118
def incomplete_utf8_sequence(byteseq):
 
119
    """Calculate the completeness of a UTF-8 encoded string.
 
120
 
 
121
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
 
122
    the end of the string which comprise an incomplete UTF-8 character
 
123
    sequence.
 
124
 
 
125
    If the string is empty or ends with a complete character OR INVALID
 
126
    sequence, returns 0.
 
127
    Otherwise, returns 1-3 indicating the number of bytes in the final
 
128
    incomplete (but valid) character sequence.
 
129
 
 
130
    Does not check any bytes before the final sequence for correctness.
 
131
 
 
132
    >>> incomplete_utf8_sequence("")
 
133
    0
 
134
    >>> incomplete_utf8_sequence("xy")
 
135
    0
 
136
    >>> incomplete_utf8_sequence("xy\xc3\xbc")
 
137
    0
 
138
    >>> incomplete_utf8_sequence("\xc3")
 
139
    1
 
140
    >>> incomplete_utf8_sequence("\xbc\xc3")
 
141
    1
 
142
    >>> incomplete_utf8_sequence("xy\xbc\xc3")
 
143
    1
 
144
    >>> incomplete_utf8_sequence("xy\xe0\xa0")
 
145
    2
 
146
    >>> incomplete_utf8_sequence("xy\xf4")
 
147
    1
 
148
    >>> incomplete_utf8_sequence("xy\xf4\x8f")
 
149
    2
 
150
    >>> incomplete_utf8_sequence("xy\xf4\x8f\xa0")
 
151
    3
 
152
    """
 
153
    count = 0
 
154
    expect = None
 
155
    for b in byteseq[::-1]:
 
156
        b = ord(b)
 
157
        count += 1
 
158
        if b & 0x80 == 0x0:
 
159
            # 0xxxxxxx (single-byte character)
 
160
            expect = 1
 
161
            break
 
162
        elif b & 0xc0 == 0x80:
 
163
            # 10xxxxxx (subsequent byte)
 
164
            pass
 
165
        elif b & 0xe0 == 0xc0:
 
166
            # 110xxxxx (start of 2-byte sequence)
 
167
            expect = 2
 
168
            break
 
169
        elif b & 0xf0 == 0xe0:
 
170
            # 1110xxxx (start of 3-byte sequence)
 
171
            expect = 3
 
172
            break
 
173
        elif b & 0xf8 == 0xf0:
 
174
            # 11110xxx (start of 4-byte sequence)
 
175
            expect = 4
 
176
            break
 
177
        else:
 
178
            # Invalid byte
 
179
            return 0
 
180
 
 
181
        if count >= 4:
 
182
            # Seen too many "subsequent bytes", invalid
 
183
            return 0
 
184
 
 
185
    if expect is None:
 
186
        # We never saw a "first byte", invalid
 
187
        return 0
 
188
 
 
189
    # We now know expect and count
 
190
    if count >= expect:
 
191
        # Complete, or we saw an invalid sequence
 
192
        return 0
 
193
    elif count < expect:
 
194
        # Incomplete
 
195
        return count
 
196
 
 
197
def object_to_dict(attrnames, obj):
 
198
    """Convert an object into a dictionary.
 
199
 
 
200
    This takes a shallow copy of the object.
 
201
 
 
202
    @param attrnames: Set (or iterable) of names of attributes to be copied
 
203
                      into the dictionary. (We don't auto-lookup, because this
 
204
                      function needs to be used on magical objects).
 
205
    """
 
206
    return dict((k, getattr(obj, k))
 
207
        for k in attrnames if not k.startswith('_'))
 
208
 
 
209
def safe_rmtree(path, ignore_errors=False, onerror=None):
 
210
    """Recursively delete a directory tree.
 
211
 
 
212
    Copied from shutil.rmtree from Python 2.6, which does not follow symbolic
 
213
    links (it is otherwise unsafe to call as root on untrusted directories; do
 
214
    not use shutil.rmtree in this case, as you may be running Python 2.5).
 
215
 
 
216
    If ignore_errors is set, errors are ignored; otherwise, if onerror
 
217
    is set, it is called to handle the error with arguments (func,
 
218
    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
 
219
    path is the argument to that function that caused it to fail; and
 
220
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
 
221
    is false and onerror is None, an exception is raised.
 
222
 
 
223
    """
 
224
    if ignore_errors:
 
225
        def onerror(*args):
 
226
            pass
 
227
    elif onerror is None:
 
228
        def onerror(*args):
 
229
            raise
 
230
    try:
 
231
        if os.path.islink(path):
 
232
            # symlinks to directories are forbidden, see bug #1669
 
233
            raise OSError("Cannot call safe_rmtree on a symbolic link")
 
234
    except OSError:
 
235
        onerror(os.path.islink, path, sys.exc_info())
 
236
        # can't continue even if onerror hook returns
 
237
        return
 
238
    names = []
 
239
    try:
 
240
        names = os.listdir(path)
 
241
    except os.error, err:
 
242
        onerror(os.listdir, path, sys.exc_info())
 
243
    for name in names:
 
244
        fullname = os.path.join(path, name)
 
245
        try:
 
246
            mode = os.lstat(fullname).st_mode
 
247
        except os.error:
 
248
            mode = 0
 
249
        if stat.S_ISDIR(mode):
 
250
            safe_rmtree(fullname, ignore_errors, onerror)
 
251
        else:
 
252
            try:
 
253
                os.remove(fullname)
 
254
            except os.error, err:
 
255
                onerror(os.remove, fullname, sys.exc_info())
 
256
    try:
 
257
        os.rmdir(path)
 
258
    except os.error:
 
259
        onerror(os.rmdir, path, sys.exc_info())