removed clean_str concept from words

pygcode/__init__.py

@@ -12,6 +12,7 @@ __all__ = [
 
     # GCodes
     'words2gcodes', 'text2gcodes', 'split_gcodes',
+    # $ python -c "from pygcode.gcodes import GCode, _subclasses as sc; print(',\\n    '.join(sorted('\\'%s\\'' % g.__name__ for g in sc(GCode))))"python -c "from pygcode.gcodes import GCode, _subclasses as sc; print(',\\n    '.join(sorted('\\'%s\\'' % g.__name__ for g in sc(GCode))))"
     'GCode',
     'GCodeAbsoluteArcDistanceMode',
     'GCodeAbsoluteDistanceMode',
@@ -133,7 +134,7 @@ __all__ = [
     'GCodeUseInches',
     'GCodeUseMillimeters',
     'GCodeUserDefined',
-    'GCodeWaitOnInput',
+    'GCodeWaitOnInput'
 ]
 
 # Machine
@@ -162,7 +163,7 @@ from .words import (
 from .gcodes import (
     words2gcodes, text2gcodes, split_gcodes,
 
-    # $ python -c "from pygcode.gcodes import _gcode_class_infostr; print(_gcode_class_infostr())"
+    # $ python -c "from pygcode.gcodes import _gcode_class_infostr as x; print(x(prefix='    # '))"
     #       - GCode:
     #         - GCodeCannedCycle:
     # G89       - GCodeBoringCycleDwellFeedOut: G89: Boring Cycle, Dwell, Feed Out
@@ -286,7 +287,7 @@ from .gcodes import (
     # G20       - GCodeUseInches: G20: use inches for length units
     # G21       - GCodeUseMillimeters: G21: use millimeters for length units
 
-    # $ python -c "from pygcode.gcodes import GCode, _subclasses; print(',\\n'.join(sorted(g.__name__ for g in _subclasses(GCode))))"python -c "from pygcode.gcodes import GCode, _subclasses; print(',\\n'.join(sorted(g.__name__ for g in _subclasses(GCode))))"
+    # $ python -c "from pygcode.gcodes import GCode, _subclasses as sc; print(',\\n    '.join(sorted(g.__name__ for g in sc(GCode))))"
     GCode,
     GCodeAbsoluteArcDistanceMode,
     GCodeAbsoluteDistanceMode,
@@ -408,5 +409,5 @@ from .gcodes import (
     GCodeUseInches,
     GCodeUseMillimeters,
     GCodeUserDefined,
-    GCodeWaitOnInput,
+    GCodeWaitOnInput
 )

pygcode/block.py

@@ -77,4 +77,4 @@ class Block(object):
             ))
 
     def __str__(self):
-        return ' '.join(str(x) for x in (self.gcodes + [p.clean_str for p in self.modal_params]))
+        return ' '.join(str(x) for x in (self.gcodes + self.modal_params))

pygcode/gcodes.py

@@ -191,11 +191,11 @@ class GCode(object):
         param_str = ''
         if self.params:
             param_str += ' ' + ' '.join([
-                "{}".format(self.params[k].clean_str)
+                "{}".format(self.params[k])
                 for k in sorted(self.params.keys())
             ])
         return "{gcode}{parameters}".format(
-            gcode=self.word.clean_str,
+            gcode=self.word,
             parameters=param_str,
         )
 
@@ -1237,7 +1237,7 @@ def _subclasses(root_class):
         yield cls
 
 
-def _gcode_class_infostr(base_class=GCode):
+def _gcode_class_infostr(base_class=GCode, prefix=''):
     """
     List all ineheriting classes for the given gcode class
     :param base_class: root of hierarcy
@@ -1247,8 +1247,9 @@ def _gcode_class_infostr(base_class=GCode):
     for (cls, level) in _subclasses_level(base_class):
         word_str = ''
         if cls.word_key:
-            word_str = cls.word_key.clean_str
+            word_str = str(cls.word_key)
-        info_str += "{word} {indent}- {name}: {description}\n".format(
+        info_str += "{prefix}{word} {indent}- {name}: {description}\n".format(
+            prefix=prefix,
             word="%-5s" % word_str,
             indent=(level * "  "),
             name=cls.__name__,

pygcode/words.py

@@ -208,21 +208,15 @@ class Word(object):
             (letter, value) = args
         else:
             # Word('G90')
-            word_str = args[0]
+            letter = args[0][0] # first letter
-            letter = word_str[0] # first letter
+            value = args[0][1:] # rest of string
-            value = word_str[1:] # rest of string
+        letter = letter.upper()
 
-        self.letter = letter.upper()
+        self._value_class = WORD_MAP[letter]['class']
+        self._value_clean = WORD_MAP[letter]['clean_value']
 
-        self._value_str = None
+        self.letter = letter
-        self._value = None
+        self._value = self._value_class(value)
-        if isinstance(value, six.string_types):
-            self._value_str = value
-        else:
-            self._value = value
-
-        self._value_class = WORD_MAP[self.letter]['class']
-        self._value_clean = WORD_MAP[self.letter]['clean_value']
 
     def __str__(self):
         return "{letter}{value}".format(
@@ -230,14 +224,6 @@ class Word(object):
             value=self.value_str,
         )
 
-    @property
-    def clean_str(self):
-        """same as __str__ but with a cleaned value (eg: X.4 is X0.4)"""
-        return "{letter}{value}".format(
-            letter=self.letter,
-            value=self.value_cleanstr,
-        )
-
     def __repr__(self):
         return "<{class_name}: {string}>".format(
             class_name=self.__class__.__name__,
@@ -255,30 +241,19 @@ class Word(object):
     def __hash__(self):
         return hash((self.letter, self.value))
 
-
-    # Value Properties
     @property
     def value_str(self):
-        """Value string, or string representation of value"""
-        if self._value_str is None:
-            return str(self._value)
-        return self._value_str
-
-    @property
-    def value_cleanstr(self):
         """Clean string representation, for consistent file output"""
         return self._value_clean(self.value)
 
+    # Value Properties
     @property
     def value(self):
-        if self._value is None:
-            return self._value_class(self._value_str)
         return self._value
 
     @value.setter
     def value(self, new_value):
         self._value = self._value_class(new_value)
-        self._value_str = None
 
     # Order
     def __lt__(self, other):