rename loader to reader

diff --git a/pymeshio/common.py b/pymeshio/common.py
index c8c2d75..45a7ff0 100644 (file)
--- a/pymeshio/common.py
+++ b/pymeshio/common.py
@@ -276,8 +276,8 @@ def readall(path):
         return f.read()\r
 \r
 \r
-class BinaryLoader(object):\r
-    """general BinaryLoader\r
+class BinaryReader(object):\r
+    """general BinaryReader\r
     """\r
     def __init__(self, ios):\r
         self.ios=ios\r

diff --git a/pymeshio/mqo/loader.py b/pymeshio/mqo/reader.py
similarity index 89%
rename from pymeshio/mqo/loader.py
rename to pymeshio/mqo/reader.py
index 60f7318..b3e0919 100644 (file)
--- a/pymeshio/mqo/loader.py
+++ b/pymeshio/mqo/reader.py
@@ -15,8 +15,8 @@ import pymeshio.mqo
 """\r
 \r
 \r
-class Loader(object):\r
-    """mqo loader\r
+class Reader(object):\r
+    """mqo reader\r
     """\r
     __slots__=[\r
             "has_mikoto",\r
@@ -168,27 +168,27 @@ class Loader(object):
         return False\r
 \r
 \r
-def load_from_file(path):\r
+def read_from_file(path):\r
     with open(path, 'rb') as ios:\r
-        load(ios)\r
+        read(ios)\r
 \r
 \r
-def load(ios):\r
+def read(ios):\r
     assert(isinstance(ios, io.IOBase))\r
-    loader=Loader(ios)\r
+    reader=Reader(ios)\r
     model=pymeshio.mqo.Model()\r
 \r
-    line=loader.getline()\r
+    line=reader.getline()\r
     if line!="Metasequoia Document":\r
         print("invalid signature")\r
         return False\r
 \r
-    line=loader.getline()\r
+    line=reader.getline()\r
     if line!="Format Text Ver 1.0":\r
         print("unknown version: %s" % line)\r
 \r
     while True:\r
-        line=loader.getline()\r
+        line=reader.getline()\r
         if line==None:\r
             # eof\r
             break;\r
@@ -201,22 +201,22 @@ def load(ios):
         if key=="Eof":\r
             return model\r
         elif key=="Scene":\r
-            if not loader.readChunk():\r
+            if not reader.readChunk():\r
                 return\r
         elif key=="Material":\r
-            materials=loader.readMaterial()\r
+            materials=reader.readMaterial()\r
             if not materials:\r
                 return\r
             model.materials=materials\r
         elif key=="Object":\r
             firstQuote=line.find('"')\r
             secondQuote=line.find('"', firstQuote+1)\r
-            obj=loader.readObject(line[firstQuote+1:secondQuote])\r
+            obj=reader.readObject(line[firstQuote+1:secondQuote])\r
             if not obj:\r
                 return\r
             model.objects.append(obj)\r
         elif key=="BackImage":\r
-            if not loader.readChunk():\r
+            if not reader.readChunk():\r
                 return\r
         elif key=="IncludeXml":\r
             firstQuote=line.find('"')\r
@@ -224,7 +224,7 @@ def load(ios):
             print("IncludeXml", line[firstQuote+1:secondQuote])\r
         else:\r
             print("unknown key: %s" % key)\r
-            if not loader.readChunk():\r
+            if not reader.readChunk():\r
                 return\r
     # error not reach here\r
     raise ParseException("invalid eof")\r

diff --git a/pymeshio/pmd/__init__.py b/pymeshio/pmd/__init__.py
index e8c9a44..df77c79 100644 (file)
--- a/pymeshio/pmd/__init__.py
+++ b/pymeshio/pmd/__init__.py
@@ -535,7 +535,7 @@ class Model(object):
     def getUV(self, i): return self.vertices[i].uv
 
     def __str__(self):
-        return '<PMDLoader version: %g, model: "%s", vertex: %d, face: %d, material: %d, bone: %d ik: %d, skin: %d>' % (
+        return '<pmd-%g, "%s" vertex: %d, face: %d, material: %d, bone: %d ik: %d, skin: %d>' % (
             self.version, self.name, len(self.vertices), len(self.indices),
             len(self.materials), len(self.bones), len(self.ik_list), len(self.morph_list))
 
@@ -567,7 +567,7 @@ class IO(object):
 
     def read(self, path):
         warnings.warn("'pymeshio.mqo.IO.read' will be replaced by 'pymeshio.mqo.loader.load'")
-        model=pymeshio.pmd.loader.load_from_file(path)
+        model=pymeshio.pmd.reader.read_from_file(path)
         if model:
             return True
 

diff --git a/pymeshio/pmd/loader.py b/pymeshio/pmd/reader.py
similarity index 71%
rename from pymeshio/pmd/loader.py
rename to pymeshio/pmd/reader.py
index 3f16099..e370147 100644 (file)
--- a/pymeshio/pmd/loader.py
+++ b/pymeshio/pmd/reader.py
@@ -4,11 +4,11 @@ import pymeshio.common
 import pymeshio.pmd\r
 \r
 \r
-class Loader(pymeshio.common.BinaryLoader):\r
-    """pmx loader\r
+class Reader(pymeshio.common.BinaryReader):\r
+    """pmx reader\r
     """\r
     def __init__(self, ios, version):\r
-        super(Loader, self).__init__(ios)\r
+        super(Reader, self).__init__(ios)\r
         self.version=version\r
 \r
     def read_text(self, size):\r
@@ -107,95 +107,95 @@ class Loader(pymeshio.common.BinaryLoader):
 \r
 \r
 \r
-def __load(loader, model):\r
+def __read(reader, model):\r
     # model info\r
-    model.name=loader.read_text(20)\r
-    model.comment=loader.read_text(256) \r
+    model.name=reader.read_text(20)\r
+    model.comment=reader.read_text(256) \r
 \r
     # model data\r
-    model.vertices=[loader.read_vertex()\r
-            for _ in range(loader.read_uint(4))]\r
-    model.indices=[loader.read_uint(2)\r
-            for _ in range(loader.read_uint(4))]\r
-    model.materials=[loader.read_material()\r
-            for _ in range(loader.read_uint(4))]\r
-    model.bones=[loader.read_bone()\r
-            for _ in range(loader.read_uint(2))]\r
-    model.ik_list=[loader.read_ik()\r
-            for _ in range(loader.read_uint(2))]\r
-    model.morphs=[loader.read_morph()\r
-            for _ in range(loader.read_uint(2))]\r
-    model.morph_indices=[loader.read_uint(2)\r
-            for _ in range(loader.read_uint(1))]\r
-    model.bone_group_list=[loader.read_text(50)\r
-            for _ in range(loader.read_uint(1))]\r
-    model.bone_display_list=[(loader.read_uint(2), loader.read_uint(1))\r
-            for _i in range(loader.read_uint(4))]\r
-\r
-    if loader.is_end():\r
+    model.vertices=[reader.read_vertex()\r
+            for _ in range(reader.read_uint(4))]\r
+    model.indices=[reader.read_uint(2)\r
+            for _ in range(reader.read_uint(4))]\r
+    model.materials=[reader.read_material()\r
+            for _ in range(reader.read_uint(4))]\r
+    model.bones=[reader.read_bone()\r
+            for _ in range(reader.read_uint(2))]\r
+    model.ik_list=[reader.read_ik()\r
+            for _ in range(reader.read_uint(2))]\r
+    model.morphs=[reader.read_morph()\r
+            for _ in range(reader.read_uint(2))]\r
+    model.morph_indices=[reader.read_uint(2)\r
+            for _ in range(reader.read_uint(1))]\r
+    model.bone_group_list=[reader.read_text(50)\r
+            for _ in range(reader.read_uint(1))]\r
+    model.bone_display_list=[(reader.read_uint(2), reader.read_uint(1))\r
+            for _i in range(reader.read_uint(4))]\r
+\r
+    if reader.is_end():\r
         # EOF\r
         return True\r
 \r
     ############################################################\r
     # extend1: english name\r
     ############################################################\r
-    if loader.read_uint(1)==0:\r
+    if reader.read_uint(1)==0:\r
         print("no extend flag")\r
         return True\r
-    model.english_name=loader.read_text(20)\r
-    model.english_comment=loader.read_text(256)\r
+    model.english_name=reader.read_text(20)\r
+    model.english_comment=reader.read_text(256)\r
     for bone in model.bones:\r
-        bone.english_name=loader.read_text(20)\r
+        bone.english_name=reader.read_text(20)\r
     for morph in model.morphs:\r
         if morph.name==b'base':\r
             continue\r
-        morph.english_name=loader.read_text(20)\r
-    model.bone_group_english_list=[loader.read_text(50)\r
+        morph.english_name=reader.read_text(20)\r
+    model.bone_group_english_list=[reader.read_text(50)\r
             for _ in model.bone_group_list]\r
 \r
     ############################################################\r
     # extend2: toon_textures\r
     ############################################################\r
-    if loader.is_end():\r
+    if reader.is_end():\r
         # EOF\r
         return True\r
-    model.toon_textures=[loader.read_text(100)\r
+    model.toon_textures=[reader.read_text(100)\r
             for _ in range(10)]\r
 \r
     ############################################################\r
     # extend2: rigidbodies and joints\r
     ############################################################\r
-    if loader.is_end():\r
+    if reader.is_end():\r
         # EOF\r
         return True\r
-    model.rigidbodies=[loader.read_rigidbody()\r
-            for _ in range(loader.read_uint(4))]\r
-    model.joints=[loader.read_joint()\r
-            for _ in range(loader.read_uint(4))]\r
+    model.rigidbodies=[reader.read_rigidbody()\r
+            for _ in range(reader.read_uint(4))]\r
+    model.joints=[reader.read_joint()\r
+            for _ in range(reader.read_uint(4))]\r
 \r
     return True\r
 \r
 \r
-def load_from_file(path):\r
-    return load(io.BytesIO(pymeshio.common.readall(path)))\r
+def read_from_file(path):\r
+    return read(io.BytesIO(pymeshio.common.readall(path)))\r
 \r
 \r
-def load(ios):\r
+def read(ios):\r
     assert(isinstance(ios, io.IOBase))\r
-    loader=pymeshio.common.BinaryLoader(ios)\r
+    reader=pymeshio.common.BinaryReader(ios)\r
 \r
     # header\r
-    signature=loader.unpack("3s", 3)\r
+    signature=reader.unpack("3s", 3)\r
     if signature!=b"Pmd":\r
         raise pymeshio.common.ParseException(\r
                 "invalid signature: {0}".format(signature))\r
-    version=loader.read_float()\r
+    version=reader.read_float()\r
 \r
     model=pymeshio.pmd.Model(version)\r
-    loader=Loader(loader.ios, version)\r
-    if(__load(loader, model)):\r
+    reader=Reader(reader.ios, version)\r
+    if(__read(reader, model)):\r
         # check eof\r
-        if not loader.is_end():\r
+        if not reader.is_end():\r
             #print("can not reach eof.")\r
             pass\r
 \r

diff --git a/pymeshio/pmx/loader.py b/pymeshio/pmx/reader.py
similarity index 83%
rename from pymeshio/pmx/loader.py
rename to pymeshio/pmx/reader.py
index b78ed96..cfb228e 100644 (file)
--- a/pymeshio/pmx/loader.py
+++ b/pymeshio/pmx/reader.py
@@ -4,8 +4,8 @@ import pymeshio.common
 import pymeshio.pmx\r
 \r
 \r
-class Loader(pymeshio.common.BinaryLoader):\r
-    """pmx loader\r
+class Reader(pymeshio.common.BinaryReader):\r
+    """pmx reader\r
     """\r
     def __init__(self, ios,\r
             text_encoding,\r
@@ -17,7 +17,7 @@ class Loader(pymeshio.common.BinaryLoader):
             morph_index_size,\r
             rigidbody_index_size\r
             ):\r
-        super(Loader, self).__init__(ios)\r
+        super(Reader, self).__init__(ios)\r
         self.read_text=self.get_read_text(text_encoding)\r
         if extended_uv>0:\r
             raise pymeshio.common.ParseException(\r
@@ -30,7 +30,7 @@ class Loader(pymeshio.common.BinaryLoader):
         self.read_rigidbody_index=lambda : self.read_uint(rigidbody_index_size)\r
 \r
     def __str__(self):\r
-        return '<pymeshio.pmx.Loader>'\r
+        return '<pymeshio.pmx.Reader>'\r
 \r
     def get_read_text(self, text_encoding):\r
         if text_encoding==0:\r
@@ -267,41 +267,41 @@ class Loader(pymeshio.common.BinaryLoader):
                 spring_constant_rotation=self.read_vector3())\r
 \r
 \r
-def load_from_file(path):\r
-    return load(io.BytesIO(pymeshio.common.readall(path)))\r
+def read_from_file(path):\r
+    return read(io.BytesIO(pymeshio.common.readall(path)))\r
 \r
 \r
-def load(ios):\r
+def read(ios):\r
     assert(isinstance(ios, io.IOBase))\r
-    loader=pymeshio.common.BinaryLoader(ios)\r
+    reader=pymeshio.common.BinaryReader(ios)\r
 \r
     # header\r
-    signature=loader.unpack("4s", 4)\r
+    signature=reader.unpack("4s", 4)\r
     if signature!=b"PMX ":\r
         raise pymeshio.common.ParseException(\r
                 "invalid signature", signature)\r
 \r
-    version=loader.read_float()\r
+    version=reader.read_float()\r
     if version!=2.0:\r
         print("unknown version", version)\r
     model=pymeshio.pmx.Model(version)\r
 \r
     # flags\r
-    flag_bytes=loader.read_uint(1)\r
+    flag_bytes=reader.read_uint(1)\r
     if flag_bytes!=8:\r
         raise pymeshio.common.ParseException(\r
-                "invalid flag length", loader.flag_bytes)\r
-    text_encoding=loader.read_uint(1)\r
-    extended_uv=loader.read_uint(1)\r
-    vertex_index_size=loader.read_uint(1)\r
-    texture_index_size=loader.read_uint(1)\r
-    material_index_size=loader.read_uint(1)\r
-    bone_index_size=loader.read_uint(1)\r
-    morph_index_size=loader.read_uint(1)\r
-    rigidbody_index_size=loader.read_uint(1)\r
+                "invalid flag length", reader.flag_bytes)\r
+    text_encoding=reader.read_uint(1)\r
+    extended_uv=reader.read_uint(1)\r
+    vertex_index_size=reader.read_uint(1)\r
+    texture_index_size=reader.read_uint(1)\r
+    material_index_size=reader.read_uint(1)\r
+    bone_index_size=reader.read_uint(1)\r
+    morph_index_size=reader.read_uint(1)\r
+    rigidbody_index_size=reader.read_uint(1)\r
     \r
-    # pmx custom loader\r
-    loader=Loader(loader.io,\r
+    # pmx custom reader\r
+    reader=Reader(reader.io,\r
             text_encoding,\r
             extended_uv,\r
             vertex_index_size,\r
@@ -313,30 +313,30 @@ def load(ios):
             )\r
 \r
     # model info\r
-    model.name = loader.read_text()\r
-    model.english_name = loader.read_text()\r
-    model.comment = loader.read_text()\r
-    model.english_comment = loader.read_text()\r
+    model.name = reader.read_text()\r
+    model.english_name = reader.read_text()\r
+    model.comment = reader.read_text()\r
+    model.english_comment = reader.read_text()\r
 \r
     # model data\r
-    model.vertices=[loader.read_vertex() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.indices=[loader.read_vertex_index() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.textures=[loader.read_text() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.materials=[loader.read_material() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.bones=[loader.read_bone() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.morphs=[loader.read_morgh() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.display_slots=[loader.read_display_slot() \r
-            for _ in range(loader.read_uint(4))]\r
-    model.rigidbodies=[loader.read_rigidbody()\r
-            for _ in range(loader.read_uint(4))]\r
-    model.joints=[loader.read_joint()\r
-            for _ in range(loader.read_uint(4))]\r
+    model.vertices=[reader.read_vertex() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.indices=[reader.read_vertex_index() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.textures=[reader.read_text() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.materials=[reader.read_material() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.bones=[reader.read_bone() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.morphs=[reader.read_morgh() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.display_slots=[reader.read_display_slot() \r
+            for _ in range(reader.read_uint(4))]\r
+    model.rigidbodies=[reader.read_rigidbody()\r
+            for _ in range(reader.read_uint(4))]\r
+    model.joints=[reader.read_joint()\r
+            for _ in range(reader.read_uint(4))]\r
 \r
     return model\r
 \r

diff --git a/test/mqo_test.py b/test/mqo_test.py
index 1be8cae..cb68799 100644 (file)
--- a/test/mqo_test.py
+++ b/test/mqo_test.py
@@ -1,14 +1,16 @@
 import pymeshio.mqo
+import pymeshio.mqo.reader
 import sys
 
+
 MQO_FILE="resources/cube.mqo"
 
 def test_old_mqo_load():
     io=pymeshio.mqo.IO()
     assert io.read(MQO_FILE)
 
-def test_mqo_load():
-    model=pymeshio.mqo.loader.load_from_file(MQO_FILE)
+def test_mqo_read():
+    model=pymeshio.mqo.reader.read_from_file(MQO_FILE)
     print(model.materials)
     assert pymeshio.mqo.Model==model.__class__
     assert 6==len(model.materials)

diff --git a/test/pmd_test.py b/test/pmd_test.py
index a4dc095..e394045 100644 (file)
--- a/test/pmd_test.py
+++ b/test/pmd_test.py
@@ -3,7 +3,7 @@ import sys
 import io
 import unittest
 import pymeshio.pmd
-import pymeshio.pmd.loader
+import pymeshio.pmd.reader
 import pymeshio.pmd.writer
 
 
@@ -20,8 +20,8 @@ class TestPmd(unittest.TestCase):
     def setUp(self):
         pass
 
-    def test_load(self):
-        model=pymeshio.pmd.loader.load_from_file(PMD_FILE)
+    def test_read(self):
+        model=pymeshio.pmd.reader.read_from_file(PMD_FILE)
         self.assertEqual(pymeshio.pmd.Model,  model.__class__)
         self.assertEqual(u'初音ミク'.encode('cp932'),  model.name)
         self.assertEqual(u'Miku Hatsune'.encode('cp932'),  model.english_name)
@@ -53,11 +53,11 @@ class TestPmd(unittest.TestCase):
     def test_write(self):
         # read source file
         buf=pymeshio.common.readall(PMD_FILE)
-        # load and write to out
-        model=pymeshio.pmd.loader.load(io.BytesIO(buf))
+        # read and write to out
+        model=pymeshio.pmd.reader.read(io.BytesIO(buf))
         out=io.BytesIO()
         pymeshio.pmd.writer.write(out, model)
         # read out buffer again
-        model2=pymeshio.pmd.loader.load(io.BytesIO(out.getvalue()))
+        model2=pymeshio.pmd.reader.read(io.BytesIO(out.getvalue()))
         self.assertEqual(model, model2)
 

diff --git a/test/pmd_test.pyc b/test/pmd_test.pyc
index 2a940e5..bc73751 100644 (file)
Binary files a/test/pmd_test.pyc and b/test/pmd_test.pyc differ

diff --git a/test/pmx_test.py b/test/pmx_test.py
index 0a040b5..dce47b7 100644 (file)
--- a/test/pmx_test.py
+++ b/test/pmx_test.py
@@ -1,5 +1,5 @@
 # coding: utf-8\r
-import pymeshio.pmx.loader\r
+import pymeshio.pmx.reader\r
 import unittest\r
 \r
 \r
@@ -12,7 +12,7 @@ class TestPmx(unittest.TestCase):
         pass\r
 \r
     def test_read(self):\r
-        model=pymeshio.pmx.loader.load_from_file(PMX_FILE)\r
+        model=pymeshio.pmx.reader.read_from_file(PMX_FILE)\r
         self.assertEqual(pymeshio.pmx.Model,  model.__class__)\r
         self.assertEqual(u'初音ミク',  model.name)\r
         self.assertEqual(u'Miku Hatsune',  model.english_name)\r