def upload_file(self, path: str, data: InMemoryUploadedFile, unzip=True):
"""Upload file at the given `path`
Args:
path (`str`): A path relative to the directory.
data: File to write.
Raises:
`TypeError`: If `path` is null or empty.
`FileNotFoundError`: If `path` does not points to an existing file.
`FileExistsError`: If `path` points to an existing file.
`PermissionError`: If `path` points to a file outside of the current directory.
"""
path = '.' if not path else path
abspath = self._validate(path, authorize_root=True)
if not abspath.is_dir():
raise NotADirectoryError(
f"NotADirectoryError: [Errno 20] No such directory: '{path}'")
abspath, _ = uniquify_filename(abspath, data.name)
abspath = Path(abspath)
with abspath.open('wb+') as destfile:
for chunk in data.chunks():
destfile.write(chunk)
if unzip and data.content_type == 'application/zip':
shutil.unpack_archive(abspath, abspath.parent)
abspath.unlink() # delete the zip
self.commit(f'upload {data.name} into {path}')
def save(self, commit=True):
img = scale_and_crop(self.files['image'], **MARKDOWNX_IMAGE_MAX_SIZE)
thumb_io = BytesIO()
img.save(thumb_io,
self.files['image'].content_type.split('/')[-1].upper())
file_name = str(self.files['image'])
thumb_io.seek(0, os.SEEK_END)
img = InMemoryUploadedFile(thumb_io, "image", file_name,
self.files['image'].content_type,
thumb_io.tell(), None)
unique_file_name = self.get_unique_file_name(file_name)
full_path = os.path.join(settings.MEDIA_ROOT, MARKDOWNX_MEDIA_PATH,
unique_file_name)
if not os.path.exists(os.path.dirname(full_path)):
os.makedirs(os.path.dirname(full_path))
destination = open(full_path, 'wb+')
for chunk in img.chunks():
destination.write(chunk)
destination.close()
return os.path.join(settings.MEDIA_URL, MARKDOWNX_MEDIA_PATH,
unique_file_name)
def write_upload_img(path, file: InMemoryUploadedFile):
"""
将文件存储到磁盘
:param path: 文件的存储路径、相对于 media
:param file: 文件对象
:return: 返回文件相对路径
"""
# 获取文件的名称
file_name = file.name
# 获取文件的名 和 后缀
index = file_name.rfind(".")
_n = file_name if index == -1 else file_name[:index]
_e = "" if index == -1 else file_name[index:]
# 随机产生文件的后缀、防止重复
_random_text = "".join(random.choices(string.ascii_letters, k=6))
# 获取文件名
file_name = _n + _random_text if index == -1 else _n + _random_text + _e
# 判断跟目录是否存在
if not os.path.exists(os.path.join(settings.MEDIA_ROOT, path)):
os.makedirs(os.path.join(settings.MEDIA_ROOT, path))
# 进行存储
with open(os.path.join(settings.MEDIA_ROOT, path, file_name), "wb") as f:
for chunk in file.chunks():
f.write(chunk)
return os.path.join(path, file_name)
def write_uploaded_file(in_memory_file: InMemoryUploadedFile) -> str:
"""
:param in_memory_file: An WSGI in memory file
:param write_path: The path which the file should be written to on disk
:return: A str of path to file on disk.
"""
try:
stage_dir = settings.EXPORT_STAGING_ROOT.rstrip("\/")
uid = str(uuid4())
dir_name = os.path.join(stage_dir, uid)
os.mkdir(dir_name)
file_name = in_memory_file.name
file_name, file_extension = os.path.splitext(file_name)
if not file_name or not file_extension:
raise Exception("No file type detected")
# Remove all non-word characters
file_name = re.sub(r"[^\w\s]", "", file_name)
# Replace all whitespace with a single underscore
file_name = re.sub(r"\s+", "_", file_name).lower()
file_name = f"{file_name}-{uid}"
out_path = os.path.join(dir_name,
"in_{0}{1}".format(file_name, file_extension))
with open(out_path, "wb+") as temp_file:
for chunk in in_memory_file.chunks():
temp_file.write(chunk)
return out_path
except Exception as e:
logger.debug(e, exc_info=True)
raise Exception("Could not write file to disk")
def _store_local(filelike: InMemoryUploadedFile) -> Tuple[str, str]:
name = filelike.name + str(time())
m = md5()
m.update(name.encode('utf-8'))
ret_name: str = m.hexdigest()
tmpdir = 'tmp/'
path = tmpdir + ret_name
if not os.path.exists(tmpdir):
os.makedirs(tmpdir)
with default_storage.open(path, 'wb+') as destination:
for chunk in filelike.chunks():
destination.write(chunk)
return filelike.name, os.path.join(settings.MEDIA_ROOT, path)
def test_post_upload_succeed(self, uuid_uuid1):
found = resolve('/image/upload/', urlconf=adminpage.urls)
request = Mock(wraps=HttpRequest(), method='POST')
file = MultiValueDict()
file['image'] = InMemoryUploadedFile(None, None, "1", 'image/jpg', None, 'utf-8')
file['image'].chunks = Mock(return_value=[b"1"])
request.FILES = file
request.body = Mock()
request.body.decode = Mock(return_value='{}')
request.user = Mock()
request.user.is_authenticated = Mock(return_value=True)
uuid.uuid1.return_value = 1
response = json.loads(found.func(request).content.decode())
self.assertEqual(response['code'], 0)
def name_save_file(file: InMemoryUploadedFile) -> str:
"""
Saves a file using a random name and returns the name
"""
file_extension = file.name.split('.')[-1]
target_file_name = '.' + file_extension
target_file_name = random_string(20 -
len(target_file_name)) + target_file_name
with open(os.path.join(IMAGES_DIR, target_file_name),
'wb+') as destination:
for chunk in file.chunks():
destination.write(chunk)
return target_file_name
def save_image(uploaded_file: InMemoryUploadedFile, user) -> Image:
"""process requested file
Parameters
----------
uploaded_file : InMemoryUploadedFile
file uploaded by the user
user : object
the user who uploaded the image
Returns
-------
Image object
the new image object that has been created
"""
# get valid file type
valid_file_types = ImageConfig.objects.load().valid_image_formats
valid_file_types_str = ','.join(valid_file_types)
logger.debug(f'valid file types: {valid_file_types_str}')
# get file name
file_name = uploaded_file.name
# check file extension
_, file_extension = os.path.splitext(file_name)
if not file_extension in valid_file_types:
raise TypeError #django error
# create unique path to save file to
uuid_name = f'{uuid.uuid4()}{file_extension}'
save_path = os.path.join(SAVED_IMAGES, uuid_name)
logger.info(f'Saving image at {save_path}')
upload_path = '/' + os.path.relpath(save_path, UPLOADED_STATIC_FILES)
logger.info(f'Image can be found at /static{upload_path}')
# write file to path
with open(save_path, 'wb+') as destination:
for chunk in uploaded_file.chunks():
destination.write(chunk)
# save image object
return Image.objects.create(
name=file_name,
file_path=save_path,
upload_path=upload_path,
owner=user,
)
def test_can_create_pil_image_from_uploaded_image(self):
with open(os.path.join(settings.BASE_DIR, 'xray.jpg'), 'rb') as fp:
img_a = Image.open(fp)
fp.seek(0)
up_file = InMemoryUploadedFile(
fp, 'image', 'xray.jpg', 'image/jpg',
os.path.getsize(os.path.join(settings.BASE_DIR, 'xray.jpg')),
'latin1')
b = io.BytesIO()
for chunk in up_file.chunks():
b.write(bytes(chunk))
b.seek(0)
img_b = Image.open(b)
self.assertEqual(img_a, img_b)
def save(self, commit=True):
img = scale_and_crop(self.files['image'], **MARKDOWNX_IMAGE_MAX_SIZE)
thumb_io = BytesIO()
img.save(thumb_io, self.files['image'].content_type.split('/')[-1].upper())
file_name = str(self.files['image'])
thumb_io.seek(0, os.SEEK_END)
img = InMemoryUploadedFile(thumb_io, "image", file_name, self.files['image'].content_type, thumb_io.tell(), None)
unique_file_name = self.get_unique_file_name(file_name)
full_path = os.path.join(settings.MEDIA_ROOT, MARKDOWNX_MEDIA_PATH, unique_file_name)
if not os.path.exists(os.path.dirname(full_path)):
os.makedirs(os.path.dirname(full_path))
destination = open(full_path, 'wb+')
for chunk in img.chunks():
destination.write(chunk)
destination.close()
return os.path.join(settings.MEDIA_URL, MARKDOWNX_MEDIA_PATH, unique_file_name)
def save_file(self, file: InMemoryUploadedFile, filename=None) -> str:
"""
Save fule.
:param file: file from the request.
:return: path to saved file.
"""
os.makedirs(os.path.dirname(settings.UPLOADED_FILE_DIR), exist_ok=True)
if not filename:
while True:
filename = settings.UPLOADED_FILE_DIR + ''.join(
random.choices(string.ascii_lowercase, k=42))
if not os.path.isfile(filename):
break
name_puts = file.name.split('.')
if len(name_puts) > 1:
filename = f'{filename}.{name_puts[-1]}'
with open(filename, 'wb+') as destination:
for chunk in file.chunks():
destination.write(chunk)
return filename
def save_to_temp(unique_dir: UUID, file: InMemoryUploadedFile) -> str:
""" Save the file to temporary storage
Parameters
----------
unique_dir: UUID
unique directory that this operation is scoped to
file : django.core.files.uploadedfile.InMemoryUploadedFile
File uploaded by the user
Returns
-------
file_path : str
file path of the saved file
"""
file_directory = f'files/temp/{unique_dir}'
file_path = f'{file_directory}/{file.name}'
if not os.path.exists(file_directory):
os.makedirs(file_directory)
with open(file_path, 'wb+') as destination:
for chunk in file.chunks():
destination.write(chunk)
return file_path
def save_logo(logo: InMemoryUploadedFile):
file_path = os.path.abspath(f'static/media/logos/{logo.name}')
with open(file_path, 'wb+') as destination:
for chunk in logo.chunks():
destination.write(chunk)
def upload_and_search_face(request):
"""
upload and search face
:param request:
:return:
"""
image_dir = 'cv/static/FaceUpload'
if not os.path.exists(image_dir):
os.makedirs(image_dir)
tik = time.time()
result = {}
if request.method == "POST":
image = request.FILES.get("image", None)
if not image:
result['code'] = 1
result['msg'] = 'invalid image'
result['results'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
if not isinstance(image, InMemoryUploadedFile):
imgstr = request.POST.get("image", None)
if 'http' in imgstr:
response = requests.get(imgstr)
image = InMemoryUploadedFile(io.BytesIO(response.content),
name="{}.jpg".format(
str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
else:
image = InMemoryUploadedFile(
io.BytesIO(base64.b64decode(imgstr)),
name="{}.jpg".format(str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
else:
destination = open(os.path.join(image_dir, image.name), 'wb+')
for chunk in image.chunks():
destination.write(chunk)
destination.close()
result['code'] = 0
result['msg'] = 'Success'
result['results'] = face_searcher.search(
os.path.join(image_dir, image.name))['results']
result['elapse'] = round(time.time() - tik, 2)
json_str = json.dumps(result, ensure_ascii=False, cls=NumpyEncoder)
return HttpResponse(json_str)
else:
result['code'] = 3
result['msg'] = 'Invalid HTTP Method'
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
def save_in_memory_file(f: InMemoryUploadedFile, path: str):
folder_path = os.path.dirname(os.path.abspath(path))
os.makedirs(folder_path, exist_ok=True)
with open(path, 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
print(type(pic))
# 创建一个文件
# save_path = "%s/booktest/%s" % (settings.MEDIA_ROOT, pic.name)
save_path = "E:/不常用工作/已解密文件/%s" % pic.name
with open(save_path, "wb") as f:
# 获取上传文件的内容并写入打开的文件
for content in pic.chunks():
f.write(content)
# 复制一份文件放入桌面
save_path_desktop = "C:/Users/931304/Desktop/已解密文件/%s" % pic.name
with open(save_path_desktop, "wb") as f:
for content in pic.chunks():
f.write(content)
# 返回
return redirect("/decrypt")
pic_io = BytesIO(b"C:/Users/931304/Desktop")
pic = InMemoryUploadedFile(file=pic_io,
field_name="pic",
name="wenjian.xlsx",
content_type=None,
size=11854,
charset=None)
save_path = "E:/不常用工作/已解密文件/wenjian.xlsx"
with open(save_path, "wb") as f:
# 获取上传文件的内容并写入打开的文件
for content in pic.chunks():
f.write(content)
def upload_file(file: InMemoryUploadedFile):
with open('users/{}'.format(file.name), 'wb') as f:
for i in file.chunks():
f.write(i)
def upload_in_memory_uploaded_file(self, uploaded_file: InMemoryUploadedFile, directory: str, filename: str) -> None:
self.__create_directory(directory)
with open(f'{self.__base_dir}/{directory}/{filename}', 'wb+') as file:
for chunk in uploaded_file.chunks():
file.write(chunk)
def upload_and_deblur(request):
"""
upload and do Image Deblurring
:param request:
:return:
"""
tik = time.time()
from django.core.files.uploadedfile import InMemoryUploadedFile, TemporaryUploadedFile
import io
image_dir = 'cv/static/SRImgs'
if not os.path.exists(image_dir):
os.makedirs(image_dir)
result = {}
if request.method == "POST":
image = request.FILES.get("image", None)
if not isinstance(image, InMemoryUploadedFile) and not isinstance(
image, TemporaryUploadedFile):
imgstr = request.POST.get("image", None)
if imgstr is None:
result['code'] = 3
result['msg'] = 'Do not upload image larger than 2.5MB'
result['elapse'] = time.time() - tik
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
else:
if 'http://' in imgstr or 'https://' in imgstr:
response = requests.get(imgstr)
image = InMemoryUploadedFile(io.BytesIO(response.content),
name="{}.jpg".format(
str(time.time())),
size=100,
field_name="image",
content_type="image/jpeg",
charset=None)
else:
image = InMemoryUploadedFile(
io.BytesIO(base64.b64decode(imgstr)),
name="{}.jpg".format(str(time.time())),
size=100,
field_name="image",
content_type="image/jpeg",
charset=None)
if not image:
result['code'] = 2
result['msg'] = 'Invalid Image Path'
result['elapse'] = time.time() - tik
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
else:
destination = open(os.path.join(image_dir, image.name), 'wb+')
for chunk in image.chunks():
destination.write(chunk)
destination.close()
result['code'] = 0
result['msg'] = 'success'
result['elapse'] = time.time() - tik
sr_img_path = deblur(deblur_gan_v2,
os.path.join(image_dir, image.name))
result['sr_img'] = sr_img_path
json_str = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_str)
else:
result['code'] = 1
result['msg'] = 'Invalid HTTP Method'
result['elapse'] = time.time() - tik
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
def upload_and_rec_beauty(request):
"""
upload and recognize image
:param request:
:return:
"""
image_dir = 'cv/static/FaceUpload'
if not os.path.exists(image_dir):
os.makedirs(image_dir)
result = {}
if request.method == "POST":
image = request.FILES.get("image", None)
if not isinstance(image, InMemoryUploadedFile):
imgstr = request.POST.get("image", None)
if 'http' in imgstr:
response = requests.get(imgstr)
image = InMemoryUploadedFile(io.BytesIO(response.content),
name="{}.jpg".format(
str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
else:
image = InMemoryUploadedFile(
io.BytesIO(base64.b64decode(imgstr)),
name="{}.jpg".format(str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
if not image:
result['code'] = 1
result['msg'] = 'Invalid Path for Face Image'
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
else:
destination = open(os.path.join(image_dir, image.name), 'wb+')
for chunk in image.chunks():
destination.write(chunk)
destination.close()
tik = time.time()
imagepath = URL_PORT + '/static/FaceUpload/' + image.name
res = beauty_recognizer.infer(os.path.join(image_dir, image.name))
if res is not None:
result['code'] = 0
result['msg'] = 'success'
result['data'] = {
'imgpath': imagepath,
'beauty': round(res['beauty'], 2),
'detection': res['mtcnn']
}
result['elapse'] = round(time.time() - tik, 2)
else:
result['code'] = 3
result['msg'] = 'None face is detected'
result['data'] = None
result['elapse'] = round(time.time() - tik, 2)
json_str = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_str)
else:
result['code'] = 2
result['msg'] = 'Invalid HTTP Method'
result['data'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
def upload_and_rec_skin_disease(request):
"""
upload and recognize skin disease
:param request:
:return:
"""
image_dir = 'cv/static/SkinUpload'
if not os.path.exists(image_dir):
os.makedirs(image_dir)
result = {}
if request.method == "POST":
image = request.FILES.get("image", None)
if not isinstance(image, InMemoryUploadedFile):
imgstr = request.POST.get("image", None)
if 'http' in imgstr:
response = requests.get(imgstr)
image = InMemoryUploadedFile(io.BytesIO(response.content),
name="{}.jpg".format(
str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
else:
image = InMemoryUploadedFile(
io.BytesIO(base64.b64decode(imgstr)),
name="{}.jpg".format(str(time.time())),
field_name="image",
content_type="image/jpeg",
size=1347415,
charset=None)
if not image:
result['code'] = 3
result['msg'] = 'Invalid Path for Skin Image'
result['results'] = None
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
else:
destination = open(os.path.join(image_dir, image.name), 'wb+')
for chunk in image.chunks():
destination.write(chunk)
destination.close()
tik = time.time()
imagepath = URL_PORT + '/static/SkinUpload/' + image.name
skin_disease = skin_disease_recognizer.infer_from_img_file(
os.path.join(image_dir, image.name))
# skin_disease = skin_disease_recognizer.infer_from_img(destination)
result['code'] = 0
result['msg'] = 'success'
result['imgpath'] = imagepath
if max(_['probability']
for _ in skin_disease['results']) > PROB_THRESH:
result['results'] = skin_disease['results']
else:
result['results'] = [{
'disease':
'Unknown',
'probability':
skin_disease['results'][0]['probability']
}]
result['elapse'] = round(time.time() - tik, 2)
json_str = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_str)
else:
result['code'] = 3
result['msg'] = 'Invalid HTTP Method'
result['data'] = None
result['elapse'] = 0
json_result = json.dumps(result, ensure_ascii=False)
return HttpResponse(json_result)
