Skip to content

Files

hypha.apply.funds.files

SubmissionStreamFieldFile 

SubmissionStreamFieldFile(instance, field, *args, filename=None, storage=default_storage, **kwargs)

Bases: StreamFieldFile

Source code in hypha/apply/stream_forms/files.py 
25
26
27
28
29
30
31
32
33
34
35
def __init__(
    self, instance, field, *args, filename=None, storage=default_storage, **kwargs
):
    super().__init__(*args, **kwargs)
    # Field is the wagtail field that the file was uploaded to
    self.field = field
    # Instance is the parent model object that created this file object
    self.instance = instance
    self.storage = storage
    self.filename = filename or self.basename
    self._committed = False

field instance-attribute 

field = field

instance instance-attribute 

instance = instance

storage instance-attribute 

storage = storage

filename instance-attribute 

filename = filename or basename

basename property 

basename

file class-attribute instance-attribute 

file = property(_get_file, _set_file, _del_file)

path property 

path

size property 

size

modification_time property 

modification_time

closed property 

closed

is_placeholder class-attribute instance-attribute 

is_placeholder = False

url property 

url

read 

read(chunk_size=None)
Source code in hypha/apply/stream_forms/files.py 
64
65
66
67
68
69
def read(self, chunk_size=None):
    self.file.seek(0)
    if chunk_size:
        return super().read(chunk_size)
    else:
        return super().read()

serialize 

serialize()
Source code in hypha/apply/stream_forms/files.py 
95
96
97
98
99
def serialize(self):
    return {
        "url": self.url,
        "filename": self.filename,
    }

open 

open(mode='rb')
Source code in hypha/apply/stream_forms/files.py 
101
102
103
104
105
106
def open(self, mode="rb"):
    if getattr(self, "_file", None) is None:
        self.file = self.storage.open(self.name, mode)
    else:
        self.file.open(mode)
    return self

save 

save()
Source code in hypha/apply/stream_forms/files.py 
111
112
113
114
115
116
def save(self):
    name = self.generate_filename()
    name = self.storage.generate_filename(name)
    if not self._committed:
        self.name = self.storage.save(name, self.file)
    self._committed = True

delete 

delete(save=True)
Source code in hypha/apply/stream_forms/files.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
def delete(self, save=True):
    if not self:
        return
    # Only close the file if it's already open, which we know by the
    # presence of self._file
    if hasattr(self, "_file"):
        self.close()
        del self.file

    self.storage.delete(self.name)

    self.name = None
    self._committed = False

close 

close()
Source code in hypha/apply/stream_forms/files.py 
137
138
139
140
def close(self):
    file = getattr(self, "_file", None)
    if file is not None:
        file.close()

get_submission_id 

get_submission_id()
Source code in hypha/apply/funds/files.py 
17
18
19
20
21
22
23
24
def get_submission_id(self):
    from hypha.apply.funds.models import ApplicationRevision

    submission_id = self.instance.pk

    if isinstance(self.instance, ApplicationRevision):
        submission_id = self.instance.submission.pk
    return submission_id

generate_filename 

generate_filename()
Source code in hypha/apply/funds/files.py 
26
27
28
29
def generate_filename(self):
    return generate_submission_file_path(
        self.get_submission_id(), self.field.id, self.name
    )

generate_submission_file_path 

generate_submission_file_path(submission_id, field_id, file_name)
Source code in hypha/apply/funds/files.py 
 8
 9
10
11
12
13
def generate_submission_file_path(submission_id, field_id, file_name):
    path = os.path.join("submission", str(submission_id), str(field_id))
    if file_name.startswith(path):
        return file_name

    return os.path.join(path, file_name)