A read/write library for ACIS/SAT file format. However, it's too ancient and doesn't respect the current file format specs, which cannot be found on the net, so I stopped there...

acis-sat-lib.py

# adapted from http://userpages.uni-koblenz.de/~ros/acis.htm

import os

class tawriter:
    
    def __init__(self,asat):
        self.l = []
        self.sat = []
        self.asat = asat
        self.akts = ""
        
    def write(self,s):
        self.akts += str(s) + ' '
        
    def writeb(self,b,f,t):
        if b:
            self.write(t)
        else:
            self.write(f)
        
    def writevertex(self,v):
        for i in range(2):
            self.write(str(v[i]))
        
    def writeinterval(self,i):
        if i.lowfinite:
            self.write('F')
            self.write(str(i.low))
        else:
            self.write('I')
        if i.highfinite:
            self.write('F')
            self.write(str(i.high))
        else:
            write('I')
        
    def writeentity(self,p):
        olds = self.akts
        if not p:  
            self.write('$-1')
        else :
            i = self.l.index(p)
            if i >= 0:  
                self.write('$'+str(i))
            else:
                self.l.add(p)
                n = len(self.l)-1
                self.akts = ''
                self.write(str(-n)+' '+p.typ+' ')
                p.write(self);
                if n >= len(sat):
                    sat.count = n+1
                sat[n] = newstr(akts)
                akts = olds
                self.write('$'+str(n))


class taentity:
    "base class for ACIS entities"
    
    def __init__(self):
        self.typ = None
        self.s = []

    def read(self,s):
        self.s = s

    def write(self,w):
        w.write('$-1')
        
    def getp(self,s):
        if s[0] == "$":
            n = int(s[1:])
            if n >= 0:
                return n
        return None
        
    def getb(self,b,s):
        return s[0].lower() == b.lower()
        
    def getvertex(self,x,y,z):
        return (float(x),float(y),float(z))


class tabody(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.lump = self.getp(self.s[2])
        self.wire = self.getp(self.s[3])
        self.transform = self.getp(self.s[4])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.lump)
        w.writeentity(self.wire)
        w.writeentity(self.transform)


class talump(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.shell = self.getp(self.s[3])
        self.body = self.getp(self.s[4])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.shell)
        w.writeentity(self.body)


class tashell(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.subshell = self.getp(self.s[3])
        self.face = self.getp(self.s[4])
        self.wire = self.getp(self.s[5])
        self.lump = self.getp(self.s[6])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.subshell)
        w.writeentity(self.face)
        w.writeentity(self.wire)
        w.writeentity(self.lump)


class tasubshell(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.parent = self.getp(self.s[2])
        self.next = self.getp(self.s[3])
        self.child = self.getp(self.s[4])
        self.face = self.getp(self.s[5])
        self.wire = self.getp(self.s[6])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.parent)
        w.writeentity(self.next)
        w.writeentity(self.child)
        w.writeentity(self.face)
        w.writeentity(self.wire)


class taface(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.loop = self.getp(self.s[3])
        self.shell = self.getp(self.s[4])
        self.subshell = self.getp(self.s[5])
        self.surface = self.getp(self.s[6])
        self.reversed = self.getb("r",self.s[7])
        self.double = self.getb("d",self.s[8])
        if self.double: 
            self.isin = self.getb('i',s)

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.loop)
        w.writeentity(self.shell)
        w.writeentity(self.subshell)
        w.writeentity(self.surface)
        w.writeb(self.reversed,'forward','reversed')
        w.writeb(self.double,'single','double')
        if self.double:  
            w.writeb(self.isin,'out','in')


class taloop(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.coedge = self.getp(self.s[3])
        self.face = self.getp(self.s[4])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.coedge)
        w.writeentity(self.face)


class tawire(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.coedge = self.getp(self.s[3])
        self.owner = self.getp(self.s[4])
        self.subshell = self.getp(self.s[5])
        self.isin = self.getb('i',self.s[6])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.coedge)
        w.writeentity(self.owner)
        w.writeentity(self.subshell)
        w.writeb(self.isin,'out','in')


class tacoedge(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.next = self.getp(self.s[2])
        self.previous = self.getp(self.s[3])
        self.partner = self.getp(self.s[4])
        self.edge = self.getp(self.s[5])
        self.reversed = self.getb('r',self.s[6])
        self.owner = self.getp(self.s[7])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.next)
        w.writeentity(self.previous)
        w.writeentity(self.partner)
        w.writeentity(self.edge)
        w.writeb(self.reversed,'forward','reversed')
        w.writeentity(self.owner)


class taedge(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.startv = self.getp(self.s[2])
        self.endv = self.getp(self.s[3])
        self.coedge = self.getp(self.s[4])
        self.curve = self.getp(self.s[5])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.startv)
        w.writeentity(self.endv)
        w.writeentity(self.coedge)
        w.writeentity(self.curve)


class tavertex(taentity):
    
    def read(self,s):
        taentity.read(self.s[2])
        self.edge = self.getp(self.s[3])
        self.apoint = self.getp(self.s[4])

    def write(self,w):
        taentity.write(self,w)
        w.writeentity(self.edge)
        w.writeentity(self.apoint)


class tapoint(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.position = self.getvertex(self.s[2],self.s[3],self.s[4])

    def write(self,w):
        taentity.write(self,w)
        w.writevertx(self.position)


class taellipse(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.center = self.getvertex(self.s[2],self.s[3],self.s[4])
        self.normal = self.getvertex(self.s[5],self.s[6],self.s[7])
        self.major = self.getvertex(self.s[8],self.s[9],self.s[10])
        self.ratio = self.getdouble(self.s[11])
        self.data = self.getinterval(self.s[12])

    def write(self,w):
        taentity.write(self,w)
        w.writevertex(self.center)
        w.writevertex(self.normal)
        w.writevertex(self.major)
        w.writedouble(self.ratio)
        w.writeinterval(self.data)


class tastraight(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.root = self.getvertex(self.s[2],self.s[3],self.s[4])
        self.dir = self.getvertex(self.s[5],self.s[6],self.s[7])
        self.curve = self.getinterval(self.s[8])

    def write(self,w):
        taentity.write(self,w)
        w.writevertex(self.root)
        w.writevertex(self.dir)
        w.writeinterval(self.curve)


class taplane(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.root = self.getvertex(self.s[2],self.s[3],self.s[4])
        self.normal = self.getvertex(self.s[5],self.s[6],self.s[7])
        self.u = self.getvertex(self.s[8],self.s[9],self.s[10])
        self.reversedv = self.getb('r',self.s[11])
        self.urange = self.getinterval(self.s[12])
        self.vrange = self.getinterval(self.s[13])

    def write(self,w):
        taentity.write(self,w)
        w.writevertex(self.root)
        w.writevertex(self.normal)
        w.writevertex(self.u)
        w.writeb(self.reversedv,'forward_v','reversed_v')
        w.writeinterval(self.urange)
        w.writeinterval(self.vrange)


class tacone(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.center = self.getvertex(self.s[2],self.s[3],self.s[4])
        self.normal = self.getvertex(self.s[5],self.s[6],self.s[7])
        self.major = self.getvertex(self.s[8],self.s[9],self.s[10])
        self.ratio = self.getdouble(self.s[11])
        self.curve = self.getinterval(self.s[12])
        self.sine = self.getdouble(self.s[13])
        self.cosine = self.getdouble(self.s[14])
        self.scale = self.getdouble(self.s[15])
        self.reversedu = self.getb('r',self.s[16])
        self.urange = self.getinterval(self.s[17])
        self.vrange = self.getinterval(self.s[18])

    def write(self,w):
        taentity.write(self,w)
        w.writevertex(self.center)
        w.writevertex(self.normal)
        w.writevertex(self.major)
        w.writedouble(self.ratio)
        w.writeintervall(self.curve)
        w.writedouble(self.sine)
        w.writedouble(self.cosine)
        w.writedouble(self.scale)
        w.writeb(self.reversedu,'forward_v','reversed_v')
        w.writeinterval(self.urange)
        w.writeinterval(self.vrange)


class tasphere(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.center = self.getvertex(self.s[2],self.s[3],self.s[4])
        self.radius = self.getdouble(self.s[5])
        self.uvorigin = self.getvertex(self.s[6],self.s[7],self.s[8])
        self.pole = self.getvertex(self.s[9],self.s[10],self.s[11])
        self.reversedv = self.getb('r',self.s[12])


    def write(self,w):
        taentity.write(self,w)
        w.writevertex(self.center)
        w.writedouble(self.radius)
        w.writevertex(self.uvorigin)
        w.writevertex(self.pole)
        w.writeb(self.reversedv,'forward_v','reversed_v')


class tatransform(taentity):
    
    def read(self,s):
        taentity.read(self,s)
        self.affine = []
        self.affine.append(self.getvertex(self.s[2],self.s[3],self.s[4]))
        self.affine.append(self.getvertex(self.s[5],self.s[6],self.s[7]))
        self.affine.append(self.getvertex(self.s[8],self.s[9],self.s[10]))
        self.transl = self.getvertex(self.s[11],self.s[12],self.s[13])
        self.scale = self.getdouble(self.s[14])
        self.rotation = self.getb("r",self.s[15])
        self.reflection = self.getb("r",self.s[16])
        self.shear = self.getb("s",self.s[17])

    def write(self,w):
        taentity.write(self,w)
        for i in range(3):
            w.writevertex(self.affine[i])
        w.writevertex(self.transl)
        w.writedouble(self.scale)
        w.writeb(self.rotation,'no_rotate','rotate')
        w.writeb(self.reflection,'no_reflect','reflect')
        w.writeb(self.shear,'no_shear','shear')


def readsat(filename):

    if not os.path.exists(filename):
        return
    f = open(filename,"rb")
    sat = f.readlines()[3:] # skip 3 first lines which are the header
    f.close()

    entities = {}
    i = 0
    for line in sat:
        key = None
        s = line.split(" ")
        if s[0][0] == '-':
            typ = s[1]
            key = -int(s[0])
            s = s[1:]
        else:
            typ = s[0]
        print len(s),s
        if typ == 'body':
            it = tabody()
        elif typ == 'lump':
            it = talump()
        elif typ == 'transform':
            it = tatransform()
        elif typ == 'shell':
            it = tashell()
        elif typ == 'face':
            it = taface()
        elif typ == 'loop':
            it = taloop()
        elif typ == 'cone-surface':
            it = tacone()
        elif typ == 'plane-surface':
            it = taplane()
        elif typ == 'sphere-surface':
            it = taplane()
        elif typ == 'coedge':
            it = tacoedge()
        elif typ == 'edge':
            it = taedge()
        elif typ == 'vertex':
            it = tavertex()
        elif typ == 'ellipse-curve':
            it = taellipse()
        elif typ == 'straight-curve':
            it = tastraight()
        elif typ == 'point':
            it = taapoint()
        else:
            print("Unknown type: ",typ)
            it = None
        if it:
            it.read(s)
            it.typ = typ
            if key != None:
                entities[key] = it
            else:
                entities[i] = it
        i += 1
    return entities