← Back to branch summary

~grupoesoc/cubicerp-addons/7.0

« back to all changes in this revision

Viewing changes to report_geraldo/lib/geraldo/site/newsite/site-geraldo/django/core/files/base.py

  • Committer: Cubic ERP
  • Date: 2014-01-07 15:38:09 UTC
  • Revision ID: info@cubicerp.com-20140107153809-4jmif3zoi8rcveve
[ADD] cubicReport

Show diffs side-by-side

added added

removed removed

Lines of Context:
report_geraldo/lib/geraldo/site/newsite/site-geraldo/django/core/files/base.py
 
1
import os
 
2
 
 
3
from django.utils.encoding import smart_str, smart_unicode
 
4
 
 
5
try:
 
6
    from cStringIO import StringIO
 
7
except ImportError:
 
8
    from StringIO import StringIO
 
9
 
 
10
class File(object):
 
11
    DEFAULT_CHUNK_SIZE = 64 * 2**10
 
12
 
 
13
    def __init__(self, file):
 
14
        self.file = file
 
15
        self._name = file.name
 
16
        self._mode = file.mode
 
17
        self._closed = False
 
18
 
 
19
    def __str__(self):
 
20
        return smart_str(self.name or '')
 
21
 
 
22
    def __unicode__(self):
 
23
        return smart_unicode(self.name or u'')
 
24
 
 
25
    def __repr__(self):
 
26
        return "<%s: %s>" % (self.__class__.__name__, self or "None")
 
27
 
 
28
    def __nonzero__(self):
 
29
        return not not self.name
 
30
 
 
31
    def __len__(self):
 
32
        return self.size
 
33
 
 
34
    def _get_name(self):
 
35
        return self._name
 
36
    name = property(_get_name)
 
37
 
 
38
    def _get_mode(self):
 
39
        return self._mode
 
40
    mode = property(_get_mode)
 
41
 
 
42
    def _get_closed(self):
 
43
        return self._closed
 
44
    closed = property(_get_closed)
 
45
 
 
46
    def _get_size(self):
 
47
        if not hasattr(self, '_size'):
 
48
            if hasattr(self.file, 'size'):
 
49
                self._size = self.file.size
 
50
            elif os.path.exists(self.file.name):
 
51
                self._size = os.path.getsize(self.file.name)
 
52
            else:
 
53
                raise AttributeError("Unable to determine the file's size.")
 
54
        return self._size
 
55
 
 
56
    def _set_size(self, size):
 
57
        self._size = size
 
58
 
 
59
    size = property(_get_size, _set_size)
 
60
 
 
61
    def chunks(self, chunk_size=None):
 
62
        """
 
63
        Read the file and yield chucks of ``chunk_size`` bytes (defaults to
 
64
        ``UploadedFile.DEFAULT_CHUNK_SIZE``).
 
65
        """
 
66
        if not chunk_size:
 
67
            chunk_size = self.__class__.DEFAULT_CHUNK_SIZE
 
68
 
 
69
        if hasattr(self, 'seek'):
 
70
            self.seek(0)
 
71
        # Assume the pointer is at zero...
 
72
        counter = self.size
 
73
 
 
74
        while counter > 0:
 
75
            yield self.read(chunk_size)
 
76
            counter -= chunk_size
 
77
 
 
78
    def multiple_chunks(self, chunk_size=None):
 
79
        """
 
80
        Returns ``True`` if you can expect multiple chunks.
 
81
 
 
82
        NB: If a particular file representation is in memory, subclasses should
 
83
        always return ``False`` -- there's no good reason to read from memory in
 
84
        chunks.
 
85
        """
 
86
        if not chunk_size:
 
87
            chunk_size = self.DEFAULT_CHUNK_SIZE
 
88
        return self.size > chunk_size
 
89
 
 
90
    def xreadlines(self):
 
91
        return iter(self)
 
92
 
 
93
    def readlines(self):
 
94
        return list(self.xreadlines())
 
95
 
 
96
    def __iter__(self):
 
97
        # Iterate over this file-like object by newlines
 
98
        buffer_ = None
 
99
        for chunk in self.chunks():
 
100
            chunk_buffer = StringIO(chunk)
 
101
 
 
102
            for line in chunk_buffer:
 
103
                if buffer_:
 
104
                    line = buffer_ + line
 
105
                    buffer_ = None
 
106
 
 
107
                # If this is the end of a line, yield
 
108
                # otherwise, wait for the next round
 
109
                if line[-1] in ('\n', '\r'):
 
110
                    yield line
 
111
                else:
 
112
                    buffer_ = line
 
113
 
 
114
        if buffer_ is not None:
 
115
            yield buffer_
 
116
 
 
117
    def open(self, mode=None):
 
118
        if not self.closed:
 
119
            self.seek(0)
 
120
        elif os.path.exists(self.file.name):
 
121
            self.file = open(self.file.name, mode or self.file.mode)
 
122
        else:
 
123
            raise ValueError("The file cannot be reopened.")
 
124
 
 
125
    def seek(self, position):
 
126
        self.file.seek(position)
 
127
 
 
128
    def tell(self):
 
129
        return self.file.tell()
 
130
 
 
131
    def read(self, num_bytes=None):
 
132
        if num_bytes is None:
 
133
            return self.file.read()
 
134
        return self.file.read(num_bytes)
 
135
 
 
136
    def write(self, content):
 
137
        if not self.mode.startswith('w'):
 
138
            raise IOError("File was not opened with write access.")
 
139
        self.file.write(content)
 
140
 
 
141
    def flush(self):
 
142
        if not self.mode.startswith('w'):
 
143
            raise IOError("File was not opened with write access.")
 
144
        self.file.flush()
 
145
 
 
146
    def close(self):
 
147
        self.file.close()
 
148
        self._closed = True
 
149
 
 
150
class ContentFile(File):
 
151
    """
 
152
    A File-like object that takes just raw content, rather than an actual file.
 
153
    """
 
154
    def __init__(self, content):
 
155
        self.file = StringIO(content or '')
 
156
        self.size = len(content or '')
 
157
        self.file.seek(0)
 
158
        self._closed = False
 
159
 
 
160
    def __str__(self):
 
161
        return 'Raw content'
 
162
 
 
163
    def __nonzero__(self):
 
164
        return True
 
165
 
 
166
    def open(self, mode=None):
 
167
        if self._closed:
 
168
            self._closed = False
 
169
        self.seek(0)