def test_stat_unicode(self):
     # test that passing unicode would not raise UnicodeDecodeError
     import posix
     try:
         posix.stat(u"ą")
     except OSError:
         pass

 def exists(path):
     """Local re-implementation of os.path.exists."""
     try:
         stat(path)
     except EnvironmentError:
         return False
     return True

def cmp(f1, f2): # Compare two files, use the cache if possible.
       # Return 1 for identical files, 0 for different.
       # Raise exceptions if either file could not be statted, read, etc.
       s1, s2 = sig(posix.stat(f1)), sig(posix.stat(f2))
       if s1[0] <> 8 or s2[0] <> 8:
               # Either is a not a plain file -- always report as different
               return 0
       if s1 = s2:
               # type, size & mtime match -- report same
               return 1

def exists(path):
    """Local re-implementation of os.path.exists."""
    try:
        stat(path)
    except EnvironmentError, e:
        # TODO: how to get the errno under RPython?
        if not __rpython__:
            if e.errno not in (errno.ENOENT, errno.ENOTDIR, errno.ESRCH):
                raise
        return False

def exists(path):
    """Local re-implementation of os.path.exists."""
    try:
        stat(path)
    except EnvironmentError:
        e = sys.exc_info()[1]
        if e.errno not in (errno.ENOENT,errno.ENOTDIR,errno.ESRCH,):
            raise
        else:
            return False
    else:
        return True

def ismount(path):
	try:
		s1 = posix.stat(path)
		s2 = posix.stat(join(path, '..'))
	except posix.error:
		return 0 # It doesn't exist -- so not a mount point :-)
	dev1 = s1[stat.ST_DEV]
	dev2 = s2[stat.ST_DEV]
	if dev1 != dev2:
		return 1		# path/.. on a different device as path
	ino1 = s1[stat.ST_INO]
	ino2 = s2[stat.ST_INO]
	if ino1 == ino2:
		return 1		# path/.. is the same i-node as path
	return 0

def files(request, publication_id):

  publication = get_object_or_404(Publication, pk=publication_id)
  filepath = publication.file.__unicode__()

  name, ext = splitext(filepath)

  filepath_absolute = join(settings.MEDIA_ROOT, filepath)

  if not exists(filepath_absolute):
    raise Http404

  statinfo = stat(filepath_absolute)

  mimetype = mimetypes.guess_type(filepath_absolute)

  mode = getattr(settings, 'PUBLICATIONS_DOWNLOAD_MODE', '')
  if mode == 'apache':
    response = HttpResponse(content_type=mimetype)
    response['X-Sendfile'] = smart_str(filepath_absolute)
  if mode == 'nginx':
    response = HttpResponse(content_type=mimetype)
    response['X-Accel-Redirect'] = smart_str(settings.MEDIA_URL + filepath)
  else:
    response = HttpResponse(open(filepath_absolute, "r"), content_type=mimetype)

  response['Content-Length'] = statinfo.st_size
  response['Content-Disposition'] = 'attachment; filename=%s%s' % (smart_str(publication.generate_identifier()), ext)
  response['Cache-Control'] = 'no-cache, must-revalidate'

  return response

def readable(path):
    try:
        mode = posix.stat(path)[stat.ST_MODE]
    except OSError:               # File doesn't exist
        sys.stderr.write("%s not found\n"%path)
        sys.exit(1)
    if not stat.S_ISREG(mode):    # or it's not readable
        sys.stderr.write("%s not readable\n"%path)
        sys.exit(1)

 def test_posix_stat_result(self):
     try:
         import posix
     except ImportError:
         return
     expect = posix.stat(__file__)
     encoded = jsonpickle.encode(expect)
     actual = jsonpickle.decode(encoded)
     self.assertEqual(expect, actual)

def mkrealdir(name):
       st = posix.stat(name) # Get the mode
       mode = S_IMODE(st[ST_MODE])
       linkto = posix.readlink(name)
       files = posix.listdir(name)
       posix.unlink(name)
       posix.mkdir(name, mode)
       posix.chmod(name, mode)
       linkto = cat('..', linkto)
       #
       for file in files:
               if file not in ('.', '..'):
                       posix.symlink(cat(linkto, file), cat(name, file))

def mkrealfile(name):
       st = posix.stat(name) # Get the mode
       mode = S_IMODE(st[ST_MODE])
       linkto = posix.readlink(name) # Make sure again it's a symlink
       f_in = open(name, 'r') # This ensures it's a file
       posix.unlink(name)
       f_out = open(name, 'w')
       while 1:
               buf = f_in.read(BUFSIZE)
               if not buf: break
               f_out.write(buf)
       del f_out # Flush data to disk before changing mode
       posix.chmod(name, mode)

def listdir(path):  # List directory contents, using cache
    try:
        cached_mtime, list = cache[path]
        del cache[path]
    except RuntimeError:
        cached_mtime, list = -1, []
    try:
        mtime = posix.stat(path)[8]
    except posix.error:
        return []
    if mtime <> cached_mtime:
        try:
            list = posix.listdir(path)
        except posix.error:
            return []
        list.sort()
    cache[path] = mtime, list
    return list

def stat(path):
       if cache.has_key(path):
               return cache[path]
       cache[path] = ret = posix.stat(path)
       return ret

def samefile(f1, f2):
	s1 = posix.stat(f1)
	s2 = posix.stat(f2)
	return samestat(s1, s2)

def isfile(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return stat.S_ISREG(st[stat.ST_MODE])

def isdir(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return stat.S_ISDIR(st[stat.ST_MODE])

def exists(path):
	try:
		st = posix.stat(path)
	except posix.error:
		return 0
	return 1

 def do_stat(self, path):
     if not path:
         path = self._work_dir
     print posix.stat(path)

import posix

for file in posix.listdir("."):
    print file, posix.stat(file)[6]

## aifc-example-1.py 314
## anydbm-example-1.py 259
## array-example-1.py 48

def copystat(src, dst):
       st = posix.stat(src)
       mode = divmod(st[0], MODEBITS)[1]
       posix.chmod(dst, mode)
       posix.utimes(dst, st[7:9])