I have the following class to help me deal with files:
File class:
# -*- coding: utf-8 -*-
"""
file
~~~~~~~~~~~~~~~~
"""
from mimetypes import MimeTypes
from os import path
from lazyproperty import lazyproperty
class File(object):
"""Class to help dealing with files.
"""
def __init__(self, path):
"""The constructor function.
"""
self.path = path
@lazyproperty
def basename(self):
"""Return last portion of the file.
"""
return path.basename(self.path)
@lazyproperty
def extension(self):
"""The extension name of the file, from the last occurrence of the
. (period) character to end of string.
"""
remaining, extension = path.splitext(self.path)
return extension
@lazyproperty
def encoding(self):
"""The encoding of the file, if no encoding is found, None will be
the default.
"""
return self.__mime_type_and_encoding[1]
@lazyproperty
def abspath(self):
"""The absolute path of the file.
"""
return path.abspath(self.path)
@lazyproperty
def mime_type(self):
"""The mime type associated with the file, if no mime type is found,
None will be the default.
"""
return self.__mime_type_and_encoding[0]
# @private
@lazyproperty
def __mime_type_and_encoding(self):
"""Guess the type of a file based on its filename or URL, given by url.
The return value is a tuple (type, encoding) where type is None if the
type can’t be guessed (missing or unknown suffix) or a string of the
form 'type/subtype', usable for a MIME content-type header.
"""
return MimeTypes().guess_type(self.abspath)
lazyloading class:
# -*- coding: utf-8 -*-
"""
lazyproperty
~~~~~~~~~~~~~~~~
"""
class lazyproperty(object):
"""Class to create lazy properties.
"""
def __init__(self, func):
"""The constructor function.
"""
self.func = func
def __get__(self, instance, cls):
if instance is None: return self
value = self.func(instance)
setattr(instance, self.func.__name__, value)
return value
I would like to improve the lazyproperties mime_type and encoding, this two parts:
return self.__mime_type_and_encoding[1]
return self.__mime_type_and_encoding[0]
Are making my sad, this magic numbers are very bad for maintenance. What i'm doing:
I'm using python 2.5 because i'm working in this legacy code, and the only way to get the mime type of file in this version is using the MimeTypes class:
mime_type = MimeTypes().guess_type("path/to/file")
Returns a tuple, -> ("mime_type", "encoding")
Which doesn't make any sense, since i'm asking for the mime type, not the encoding... any way... so, i created the __mime_type_and_encoding lazyproperty to avoid calling the MimeTypes() two times, in the encoding and mime_type.
Is it possible to avoid the magic numbers, and still do what i want?
